From 56a5f3184d799d1d86b7193d2a309ec0f353b89f Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Sun, 4 Jan 2015 20:07:07 -0500 Subject: [PATCH 01/49] Fixed GDB pretty printer to work on enums correctly --- src/etc/gdb_rust_pretty_printing.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) mode change 100644 => 100755 src/etc/gdb_rust_pretty_printing.py diff --git a/src/etc/gdb_rust_pretty_printing.py b/src/etc/gdb_rust_pretty_printing.py old mode 100644 new mode 100755 index 7e5918ea39e1e..9fc8429248a6b --- a/src/etc/gdb_rust_pretty_printing.py +++ b/src/etc/gdb_rust_pretty_printing.py @@ -62,14 +62,16 @@ def rust_pretty_printer_lookup_function(val): assert first_variant_name.startswith("RUST$ENCODED$ENUM$") # This is a space-optimized enum last_separator_index = first_variant_name.rfind("$") - second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index) - disr_field_index = first_variant_name[second_last_separator_index + 1 : + start_index = len("RUST$ENCODED$ENUM") + disr_field_indices = first_variant_name[start_index + 1 : last_separator_index] - disr_field_index = int(disr_field_index) + disr_field_indices = [int(index) for index in disr_field_indices.split("$")] sole_variant_val = val[enum_members[0]] - disr_field = get_field_at_index(sole_variant_val, disr_field_index) - discriminant = sole_variant_val[disr_field] + discriminant = sole_variant_val + for disr_field_index in disr_field_indices: + disr_field = get_field_at_index(discriminant, disr_field_index) + discriminant = discriminant[disr_field] # If the discriminant field is a fat pointer we have to consider the # first word as the true discriminant @@ -234,4 +236,5 @@ def get_field_at_index(val, index): for field in val.type.fields(): if i == index: return field + i += 1 return None From d009a761827e45045e9570535694c7ed61a85c36 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Sun, 4 Jan 2015 20:09:43 -0500 Subject: [PATCH 02/49] Fixed GDB pretty printer more --- src/etc/gdb_rust_pretty_printing.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/etc/gdb_rust_pretty_printing.py b/src/etc/gdb_rust_pretty_printing.py index 9fc8429248a6b..3abef3dda83aa 100755 --- a/src/etc/gdb_rust_pretty_printing.py +++ b/src/etc/gdb_rust_pretty_printing.py @@ -69,8 +69,8 @@ def rust_pretty_printer_lookup_function(val): sole_variant_val = val[enum_members[0]] discriminant = sole_variant_val - for disr_field_index in disr_field_indices: - disr_field = get_field_at_index(discriminant, disr_field_index) + for disr_field_index in disr_field_indices: + disr_field = get_field_at_index(discriminant, disr_field_index) discriminant = discriminant[disr_field] # If the discriminant field is a fat pointer we have to consider the From 3d3670bc65a07f1d4dcaca8d0965d3f0ba040101 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Sun, 4 Jan 2015 23:35:29 -0500 Subject: [PATCH 03/49] Added fix to LLDB formatter --- src/etc/gdb_rust_pretty_printing.py | 8 ++++---- src/etc/lldb_rust_formatters.py | 24 ++++++++++++------------ 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/etc/gdb_rust_pretty_printing.py b/src/etc/gdb_rust_pretty_printing.py index 3abef3dda83aa..6e9aa6e80ce8c 100755 --- a/src/etc/gdb_rust_pretty_printing.py +++ b/src/etc/gdb_rust_pretty_printing.py @@ -62,10 +62,10 @@ def rust_pretty_printer_lookup_function(val): assert first_variant_name.startswith("RUST$ENCODED$ENUM$") # This is a space-optimized enum last_separator_index = first_variant_name.rfind("$") - start_index = len("RUST$ENCODED$ENUM") - disr_field_indices = first_variant_name[start_index + 1 : - last_separator_index] - disr_field_indices = [int(index) for index in disr_field_indices.split("$")] + start_index = len("RUST$ENCODED$ENUM$") + disr_field_indices = first_variant_name[start_index : + last_separator_index].split("$") + disr_field_indices = [int(index) for index in disr_field_indices] sole_variant_val = val[enum_members[0]] discriminant = sole_variant_val diff --git a/src/etc/lldb_rust_formatters.py b/src/etc/lldb_rust_formatters.py index f4f1a5121d195..b9bb3ec4fe919 100644 --- a/src/etc/lldb_rust_formatters.py +++ b/src/etc/lldb_rust_formatters.py @@ -79,11 +79,11 @@ def print_struct_val_starting_from(field_start_index, val, internal_dict): has_field_names = type_has_field_names(t) if has_field_names: - template = "%(type_name)s {\n%(body)s\n}" - separator = ", \n" + template = "%(type_name)s {\n%(body)s\n}" + separator = ", \n" else: - template = "%(type_name)s(%(body)s)" - separator = ", " + template = "%(type_name)s(%(body)s)" + separator = ", " if type_name.startswith("("): # this is a tuple, so don't print the type name @@ -125,20 +125,20 @@ def print_enum_val(val, internal_dict): if last_separator_index == -1: return "" % first_variant_name - second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index) - if second_last_separator_index == -1: - return "" % first_variant_name + start_index = len("RUST$ENCODED$ENUM$") - # Extract index of the discriminator field + # Extract indices of the discriminator field try: - disr_field_index = first_variant_name[second_last_separator_index + 1 : - last_separator_index] - disr_field_index = int(disr_field_index) + disr_field_indices = first_variant_name[start_index : + last_separator_index].split("$") + disr_field_indices = [int(index) for index in dis_field_indices] except: return "" % first_variant_name # Read the discriminant - disr_val = val.GetChildAtIndex(0).GetChildAtIndex(disr_field_index) + disr_val = val.GetChildAtIndex(0) + for index in disr_field_indices: + disr_val = disr_val.GetChildAtIndex(disr_field_index) # If the discriminant field is a fat pointer we have to consider the # first word as the true discriminant From 22cae7e034254d4c21438f464741d8ede236a23f Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Sun, 4 Jan 2015 23:43:47 -0500 Subject: [PATCH 04/49] Pylinted and slightly better commented --- src/etc/gdb_rust_pretty_printing.py | 10 +++++++--- src/etc/lldb_rust_formatters.py | 6 +++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/etc/gdb_rust_pretty_printing.py b/src/etc/gdb_rust_pretty_printing.py index 6e9aa6e80ce8c..b6770c99975f1 100755 --- a/src/etc/gdb_rust_pretty_printing.py +++ b/src/etc/gdb_rust_pretty_printing.py @@ -51,7 +51,7 @@ def rust_pretty_printer_lookup_function(val): enum_member_count = len(enum_members) if enum_member_count == 0: - return RustStructPrinter(val, false) + return RustStructPrinter(val, False) if enum_member_count == 1: first_variant_name = enum_members[0].name @@ -60,7 +60,11 @@ def rust_pretty_printer_lookup_function(val): return rust_pretty_printer_lookup_function(val[enum_members[0]]) else: assert first_variant_name.startswith("RUST$ENCODED$ENUM$") - # This is a space-optimized enum + # This is a space-optimized enum. + # This means this enum has only two states, and Rust uses one of the + # fields somewhere in the struct to determine which of the two states + # it's in. The location of the field is encoded in the name as something + # like RUST$ENCODED$ENUM$(num$)*name_of_zero_state last_separator_index = first_variant_name.rfind("$") start_index = len("RUST$ENCODED$ENUM$") disr_field_indices = first_variant_name[start_index : @@ -76,7 +80,7 @@ def rust_pretty_printer_lookup_function(val): # If the discriminant field is a fat pointer we have to consider the # first word as the true discriminant if discriminant.type.code == gdb.TYPE_CODE_STRUCT: - discriminant = discriminant[get_field_at_index(discriminant, 0)] + discriminant = discriminant[get_field_at_index(discriminant, 0)] if discriminant == 0: null_variant_name = first_variant_name[last_separator_index + 1:] diff --git a/src/etc/lldb_rust_formatters.py b/src/etc/lldb_rust_formatters.py index b9bb3ec4fe919..05d71902904b4 100644 --- a/src/etc/lldb_rust_formatters.py +++ b/src/etc/lldb_rust_formatters.py @@ -131,19 +131,19 @@ def print_enum_val(val, internal_dict): try: disr_field_indices = first_variant_name[start_index : last_separator_index].split("$") - disr_field_indices = [int(index) for index in dis_field_indices] + disr_field_indices = [int(index) for index in disr_field_indices] except: return "" % first_variant_name # Read the discriminant disr_val = val.GetChildAtIndex(0) for index in disr_field_indices: - disr_val = disr_val.GetChildAtIndex(disr_field_index) + disr_val = disr_val.GetChildAtIndex(index) # If the discriminant field is a fat pointer we have to consider the # first word as the true discriminant if disr_val.GetType().GetTypeClass() == lldb.eTypeClassStruct: - disr_val = disr_val.GetChildAtIndex(0) + disr_val = disr_val.GetChildAtIndex(0) if disr_val.GetValueAsUnsigned() == 0: # Null case: Print the name of the null-variant From 537285e707a56a95ac4001ca5637ff9f035a6989 Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Mon, 5 Jan 2015 18:27:29 +0900 Subject: [PATCH 05/49] Fix -Z no-analysis --- src/librustc/session/config.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index f9f899401b175..1c76eae71870e 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -330,7 +330,7 @@ pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> { ("parse-only", "Parse only; do not compile, assemble, or link", PARSE_ONLY), ("no-trans", "Run all passes except translation; no output", NO_TRANS), ("no-analysis", "Parse and expand the source, but run no analysis and", - NO_TRANS), + NO_ANALYSIS), ("unstable-options", "Adds unstable command line options to rustc interface", UNSTABLE_OPTIONS), ("print-enum-sizes", "Print the size of enums and their variants", PRINT_ENUM_SIZES), From 7e42338dc5e67a85821831b4f34bfb6f52c157d3 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Mon, 5 Jan 2015 13:49:33 -0500 Subject: [PATCH 06/49] Added two tests for pretty printing optimized enums --- src/test/debuginfo/gdb-pretty-struct-and-enums.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs index 64c120e1ab3a9..9b791fe1275b5 100644 --- a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs @@ -69,6 +69,13 @@ // gdb-command: print nested_variant2 // gdb-check:$16 = NestedVariant2 = {abc = NestedStruct = {regular_struct = RegularStruct = {the_first_field = 117, the_second_field = 118.5, the_third_field = false, the_fourth_field = "NestedStructString10"}, tuple_struct = TupleStruct = {119.5, 120}, empty_struct = EmptyStruct, c_style_enum = CStyleEnumVar3, mixed_enum = MixedEnumStructVar = {field1 = 121.5, field2 = -122}}} +// gdb-command: print none_check1 +// gdb-check:$16 = None + +// gdb-command: print none_check2 +// gdb-check:$17 = None + +use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; use self::MixedEnum::{MixedEnumCStyleVar, MixedEnumTupleVar, MixedEnumStructVar}; use self::NestedEnum::{NestedVariant1, NestedVariant2}; @@ -170,6 +177,9 @@ fn main() { } }; + let none_check1: Option<(uint, Vec)> = None; + let none_check2: Option = None; + zzz(); // #break } From 87eebd17cd994a1c847c4a8926663478c4670c40 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Mon, 5 Jan 2015 14:58:02 -0500 Subject: [PATCH 07/49] Fixed tests --- src/test/debuginfo/gdb-pretty-struct-and-enums.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs index 9b791fe1275b5..4472e1e047dfb 100644 --- a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs @@ -70,10 +70,10 @@ // gdb-check:$16 = NestedVariant2 = {abc = NestedStruct = {regular_struct = RegularStruct = {the_first_field = 117, the_second_field = 118.5, the_third_field = false, the_fourth_field = "NestedStructString10"}, tuple_struct = TupleStruct = {119.5, 120}, empty_struct = EmptyStruct, c_style_enum = CStyleEnumVar3, mixed_enum = MixedEnumStructVar = {field1 = 121.5, field2 = -122}}} // gdb-command: print none_check1 -// gdb-check:$16 = None +// gdb-check:$17 = None // gdb-command: print none_check2 -// gdb-check:$17 = None +// gdb-check:$18 = None use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; From d33857208f9af74fd414c79eeda40bdf50bf4574 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Mon, 5 Jan 2015 15:28:19 -0500 Subject: [PATCH 08/49] Fixed tests --- src/test/debuginfo/gdb-pretty-struct-and-enums.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs index 4472e1e047dfb..4b2628b2a1f73 100644 --- a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs @@ -75,7 +75,6 @@ // gdb-command: print none_check2 // gdb-check:$18 = None -use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3}; use self::MixedEnum::{MixedEnumCStyleVar, MixedEnumTupleVar, MixedEnumStructVar}; use self::NestedEnum::{NestedVariant1, NestedVariant2}; From 351e6b7255bbe43687c9275d63b99da3e8f5fe62 Mon Sep 17 00:00:00 2001 From: Peter Atashian Date: Tue, 6 Jan 2015 00:54:09 -0500 Subject: [PATCH 09/49] Implement TTY::get_winsize for Windows Signed-off-by: Peter Atashian --- src/libstd/sys/windows/c.rs | 30 ++++++++++++++++++++++++++++++ src/libstd/sys/windows/tty.rs | 16 +++++++++------- 2 files changed, 39 insertions(+), 7 deletions(-) diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index 1ee57434fb91a..8ee3806d7f5dc 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -84,6 +84,32 @@ pub fn fd_set(set: &mut fd_set, s: libc::SOCKET) { set.fd_count += 1; } +pub type SHORT = libc::c_short; + +#[repr(C)] +pub struct COORD { + pub X: SHORT, + pub Y: SHORT, +} + +#[repr(C)] +pub struct SMALL_RECT { + pub Left: SHORT, + pub Top: SHORT, + pub Right: SHORT, + pub Bottom: SHORT, +} + +#[repr(C)] +pub struct CONSOLE_SCREEN_BUFFER_INFO { + pub dwSize: COORD, + pub dwCursorPosition: COORD, + pub wAttributes: libc::WORD, + pub srWindow: SMALL_RECT, + pub dwMaximumWindowSize: COORD, +} +pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO; + #[link(name = "ws2_32")] extern "system" { pub fn WSAStartup(wVersionRequested: libc::WORD, @@ -247,4 +273,8 @@ extern "system" { pub fn SetConsoleMode(hConsoleHandle: libc::HANDLE, lpMode: libc::DWORD) -> libc::BOOL; + pub fn GetConsoleScreenBufferInfo( + hConsoleOutput: libc::HANDLE, + lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO, + ) -> libc::BOOL; } diff --git a/src/libstd/sys/windows/tty.rs b/src/libstd/sys/windows/tty.rs index 4305f7743b564..f9e1f0d3ed0aa 100644 --- a/src/libstd/sys/windows/tty.rs +++ b/src/libstd/sys/windows/tty.rs @@ -32,13 +32,15 @@ use iter::repeat; use libc::types::os::arch::extra::LPCVOID; use libc::{c_int, HANDLE, LPDWORD, DWORD, LPVOID}; use libc::{get_osfhandle, CloseHandle}; +use mem; use ptr; use str::from_utf8; use super::c::{ENABLE_ECHO_INPUT, ENABLE_EXTENDED_FLAGS}; use super::c::{ENABLE_INSERT_MODE, ENABLE_LINE_INPUT}; use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE}; -use super::c::{ERROR_ILLEGAL_CHARACTER}; +use super::c::{ERROR_ILLEGAL_CHARACTER, CONSOLE_SCREEN_BUFFER_INFO}; use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode}; +use super::c::{GetConsoleScreenBufferInfo}; fn invalid_encoding() -> IoError { IoError { @@ -146,12 +148,12 @@ impl TTY { } pub fn get_winsize(&mut self) -> IoResult<(int, int)> { - // FIXME - // Get console buffer via CreateFile with CONOUT$ - // Make a CONSOLE_SCREEN_BUFFER_INFO - // Call GetConsoleScreenBufferInfo - // Maybe call GetLargestConsoleWindowSize instead? - Err(super::unimpl()) + let mut info: CONSOLE_SCREEN_BUFFER_INFO = unsafe { mem::zeroed() }; + match unsafe { GetConsoleScreenBufferInfo(self.handle, &mut info as *mut _) } { + 0 => Err(super::last_error()), + _ => Ok(((info.srWindow.Right + 1 - info.srWindow.Left) as int, + (info.srWindow.Bottom + 1 - info.srWindow.Top) as int)), + } } // Let us magically declare this as a TTY From b683e879e4a88db5ab02b905486860e52d7ac600 Mon Sep 17 00:00:00 2001 From: Jared Roesch Date: Tue, 6 Jan 2015 01:07:31 -0800 Subject: [PATCH 10/49] Add check to ensure trait bounds are only placed o Add check to ensure trait bounds are only placed on ty_param --- src/librustc_typeck/check/wf.rs | 39 +++++++++++++++++-- .../where-clauses-not-parameter.rs | 29 +++++++++++--- .../run-pass/where-clauses-not-parameter.rs | 17 -------- 3 files changed, 59 insertions(+), 26 deletions(-) delete mode 100644 src/test/run-pass/where-clauses-not-parameter.rs diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index d4a5bda5f97f9..329ae85082f5f 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -86,13 +86,14 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { { let ccx = self.ccx; let item_def_id = local_def(item.id); - let polytype = ty::lookup_item_type(ccx.tcx, item_def_id); + let type_scheme = ty::lookup_item_type(ccx.tcx, item_def_id); + reject_non_type_param_bounds(ccx.tcx, item.span, &type_scheme.generics); let param_env = ty::construct_parameter_environment(ccx.tcx, - &polytype.generics, + &type_scheme.generics, item.id); let inh = Inherited::new(ccx.tcx, param_env); - let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(polytype.ty), item.id); + let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(type_scheme.ty), item.id); f(self, &fcx); vtable::select_all_fcx_obligations_or_error(&fcx); regionck::regionck_item(&fcx, item); @@ -143,10 +144,12 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item.span, region::CodeExtent::from_node_id(item.id), Some(&mut this.cache)); + let type_scheme = ty::lookup_item_type(fcx.tcx(), local_def(item.id)); let item_ty = fcx.instantiate_type_scheme(item.span, &fcx.inh.param_env.free_substs, &type_scheme.ty); + bounds_checker.check_traits_in_ty(item_ty); }); } @@ -178,6 +181,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { None => { return; } Some(t) => { t } }; + let trait_ref = fcx.instantiate_type_scheme(item.span, &fcx.inh.param_env.free_substs, &trait_ref); @@ -229,6 +233,35 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } } +// Reject any predicates that do not involve a type parameter. +fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, + span: Span, + generics: &ty::Generics<'tcx>) { + for predicate in generics.predicates.iter() { + match predicate { + &ty::Predicate::Trait(ty::Binder(ref tr)) => { + let self_ty = tr.self_ty(); + if !self_ty.walk().any(|t| is_ty_param(t)) { + tcx.sess.span_err( + span, + format!("cannot bound type `{}`, where clause \ + bounds may only be attached to types involving \ + type parameters", + self_ty.repr(tcx)).as_slice()) + } + } + _ => {} + } + } + + fn is_ty_param(ty: ty::Ty) -> bool { + match &ty.sty { + &ty::sty::ty_param(_) => true, + _ => false + } + } +} + impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { fn visit_item(&mut self, i: &ast::Item) { self.check_item_well_formed(i); diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs index 9e81703787f3e..61ef2dd36fcdc 100644 --- a/src/test/compile-fail/where-clauses-not-parameter.rs +++ b/src/test/compile-fail/where-clauses-not-parameter.rs @@ -8,17 +8,34 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A; +fn equal(_: &T, _: &T) -> bool where int : Eq { + true //~^ ERROR cannot bound type `int`, where clause bounds may only be attached +} + +// This should be fine involves a type parameter. +fn test() -> bool where Option : Eq {} + +// This should be rejected as well. +fn test2() -> bool where Option : Eq {} -trait U {} +#[derive(PartialEq)] +//~^ ERROR cannot bound type `int`, where clause bounds +enum Foo where int : Eq { MkFoo } -// impl U for A {} +fn test3() -> bool where Option> : Eq {} + +fn test4() -> bool where Option> : Eq {} +//~^ ERROR cannot bound type `core::option::Option>`, where clause bounds + +trait Baz where int : Eq { + fn baz() where String : Eq; +} -fn equal(_: &T, _: &T) -> bool where A : U { - true +impl Baz for int where int : Eq { + //~^ ERROR cannot bound type `int`, where clause bounds + fn baz() where String : Eq {} } fn main() { equal(&0i, &0i); - //~^ ERROR the trait `U` is not implemented for the type `A` } diff --git a/src/test/run-pass/where-clauses-not-parameter.rs b/src/test/run-pass/where-clauses-not-parameter.rs deleted file mode 100644 index bc5fc388ca1ea..0000000000000 --- a/src/test/run-pass/where-clauses-not-parameter.rs +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -fn equal(_: &T, _: &T) -> bool where int : Eq { - true -} - -fn main() { - equal(&0i, &0i); -} From ec133fed409d41569485a689fe07c6da035000bd Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Mon, 5 Jan 2015 20:47:21 -0500 Subject: [PATCH 11/49] cleanup: use short AT notation (`Ty::Item` instead of `::Item`) --- src/libcollections/btree/map.rs | 4 +- src/libcore/iter.rs | 153 ++++++++++++++++---------------- src/libcore/ops.rs | 2 +- src/libcore/slice.rs | 4 +- src/libserialize/serialize.rs | 8 +- 5 files changed, 84 insertions(+), 87 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index b85ea65f5ce58..5cb9cf2cb9a6e 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -933,7 +933,7 @@ enum StackOp { } impl Iterator for AbsIter where - T: DoubleEndedIterator + Iterator> + Traverse, + T: DoubleEndedIterator> + Traverse, { type Item = (K, V); @@ -1002,7 +1002,7 @@ impl Iterator for AbsIter where } impl DoubleEndedIterator for AbsIter where - T: DoubleEndedIterator + Iterator> + Traverse, + T: DoubleEndedIterator> + Traverse, { // next_back is totally symmetric to next fn next_back(&mut self) -> Option<(K, V)> { diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index e5753f6cc2e78..1880a257bfaad 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -142,7 +142,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn last(mut self) -> Option< ::Item> { + fn last(mut self) -> Option { let mut last = None; for x in self { last = Some(x); } last @@ -161,7 +161,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn nth(&mut self, mut n: uint) -> Option< ::Item> { + fn nth(&mut self, mut n: uint) -> Option { for x in *self { if n == 0 { return Some(x) } n -= 1; @@ -186,7 +186,7 @@ pub trait IteratorExt: Iterator + Sized { #[inline] #[stable] fn chain(self, other: U) -> Chain where - U: Iterator::Item>, + U: Iterator, { Chain{a: self, b: other, flag: false} } @@ -228,8 +228,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn map(self, f: F) -> Map< ::Item, B, Self, F> where - F: FnMut(::Item) -> B, + fn map(self, f: F) -> Map where + F: FnMut(Self::Item) -> B, { Map{iter: self, f: f} } @@ -248,8 +248,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn filter

(self, predicate: P) -> Filter< ::Item, Self, P> where - P: FnMut(&::Item) -> bool, + fn filter

(self, predicate: P) -> Filter where + P: FnMut(&Self::Item) -> bool, { Filter{iter: self, predicate: predicate} } @@ -268,8 +268,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn filter_map(self, f: F) -> FilterMap< ::Item, B, Self, F> where - F: FnMut(::Item) -> Option, + fn filter_map(self, f: F) -> FilterMap where + F: FnMut(Self::Item) -> Option, { FilterMap { iter: self, f: f } } @@ -312,7 +312,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn peekable(self) -> Peekable< ::Item, Self> { + fn peekable(self) -> Peekable { Peekable{iter: self, peeked: None} } @@ -332,8 +332,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn skip_while

(self, predicate: P) -> SkipWhile< ::Item, Self, P> where - P: FnMut(&::Item) -> bool, + fn skip_while

(self, predicate: P) -> SkipWhile where + P: FnMut(&Self::Item) -> bool, { SkipWhile{iter: self, flag: false, predicate: predicate} } @@ -353,8 +353,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn take_while

(self, predicate: P) -> TakeWhile< ::Item, Self, P> where - P: FnMut(&::Item) -> bool, + fn take_while

(self, predicate: P) -> TakeWhile where + P: FnMut(&Self::Item) -> bool, { TakeWhile{iter: self, flag: false, predicate: predicate} } @@ -422,8 +422,8 @@ pub trait IteratorExt: Iterator + Sized { self, initial_state: St, f: F, - ) -> Scan< ::Item, B, Self, St, F> where - F: FnMut(&mut St, ::Item) -> Option, + ) -> Scan where + F: FnMut(&mut St, Self::Item) -> Option, { Scan{iter: self, f: f, state: initial_state} } @@ -448,9 +448,9 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn flat_map(self, f: F) -> FlatMap< ::Item, B, Self, U, F> where + fn flat_map(self, f: F) -> FlatMap where U: Iterator, - F: FnMut(::Item) -> U, + F: FnMut(Self::Item) -> U, { FlatMap{iter: self, f: f, frontiter: None, backiter: None } } @@ -508,8 +508,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn inspect(self, f: F) -> Inspect< ::Item, Self, F> where - F: FnMut(&::Item), + fn inspect(self, f: F) -> Inspect where + F: FnMut(&Self::Item), { Inspect{iter: self, f: f} } @@ -546,7 +546,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn collect::Item>>(self) -> B { + fn collect>(self) -> B { FromIterator::from_iter(self) } @@ -563,8 +563,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[unstable = "recently added as part of collections reform"] fn partition(mut self, mut f: F) -> (B, B) where - B: Default + Extend< ::Item>, - F: FnMut(&::Item) -> bool + B: Default + Extend, + F: FnMut(&Self::Item) -> bool { let mut left: B = Default::default(); let mut right: B = Default::default(); @@ -592,7 +592,7 @@ pub trait IteratorExt: Iterator + Sized { #[inline] #[stable] fn fold(mut self, init: B, mut f: F) -> B where - F: FnMut(B, ::Item) -> B, + F: FnMut(B, Self::Item) -> B, { let mut accum = init; for x in self { @@ -612,7 +612,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn all(mut self, mut f: F) -> bool where F: FnMut(::Item) -> bool { + fn all(mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool { for x in self { if !f(x) { return false; } } true } @@ -630,7 +630,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn any(&mut self, mut f: F) -> bool where F: FnMut(::Item) -> bool { + fn any(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool { for x in *self { if f(x) { return true; } } false } @@ -640,8 +640,8 @@ pub trait IteratorExt: Iterator + Sized { /// Does not consume the iterator past the first found element. #[inline] #[stable] - fn find

(&mut self, mut predicate: P) -> Option< ::Item> where - P: FnMut(&::Item) -> bool, + fn find

(&mut self, mut predicate: P) -> Option where + P: FnMut(&Self::Item) -> bool, { for x in *self { if predicate(&x) { return Some(x) } @@ -653,7 +653,7 @@ pub trait IteratorExt: Iterator + Sized { #[inline] #[stable] fn position

(&mut self, mut predicate: P) -> Option where - P: FnMut(::Item) -> bool, + P: FnMut(Self::Item) -> bool, { let mut i = 0; for x in *self { @@ -671,7 +671,7 @@ pub trait IteratorExt: Iterator + Sized { #[inline] #[stable] fn rposition

(&mut self, mut predicate: P) -> Option where - P: FnMut(::Item) -> bool, + P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator { let len = self.len(); @@ -693,8 +693,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn max(self) -> Option< ::Item> where - ::Item: Ord + fn max(self) -> Option where Self::Item: Ord { self.fold(None, |max, x| { match max { @@ -714,8 +713,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable] - fn min(self) -> Option< ::Item> where - ::Item: Ord + fn min(self) -> Option where Self::Item: Ord { self.fold(None, |min, x| { match min { @@ -759,8 +757,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert!(v.iter().min_max() == MinMax(&1, &1)); /// ``` #[unstable = "return type may change"] - fn min_max(mut self) -> MinMaxResult< ::Item> where - ::Item: Ord + fn min_max(mut self) -> MinMaxResult where Self::Item: Ord { let (mut min, mut max) = match self.next() { None => return NoElements, @@ -817,10 +814,10 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[unstable = "may want to produce an Ordering directly; see #15311"] - fn max_by(self, mut f: F) -> Option< ::Item> where - F: FnMut(&::Item) -> B, + fn max_by(self, mut f: F) -> Option where + F: FnMut(&Self::Item) -> B, { - self.fold(None, |max: Option<(::Item, B)>, x| { + self.fold(None, |max: Option<(Self::Item, B)>, x| { let x_val = f(&x); match max { None => Some((x, x_val)), @@ -846,10 +843,10 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[unstable = "may want to produce an Ordering directly; see #15311"] - fn min_by(self, mut f: F) -> Option< ::Item> where - F: FnMut(&::Item) -> B, + fn min_by(self, mut f: F) -> Option where + F: FnMut(&Self::Item) -> B, { - self.fold(None, |min: Option<(::Item, B)>, x| { + self.fold(None, |min: Option<(Self::Item, B)>, x| { let x_val = f(&x); match min { None => Some((x, x_val)), @@ -968,7 +965,7 @@ impl IteratorExt for I where I: Iterator {} #[stable] pub trait DoubleEndedIterator: Iterator { /// Yield an element from the end of the range, returning `None` if the range is empty. - fn next_back(&mut self) -> Option< ::Item>; + fn next_back(&mut self) -> Option; } /// An object implementing random access indexing by `uint` @@ -984,7 +981,7 @@ pub trait RandomAccessIterator: Iterator { fn indexable(&self) -> uint; /// Return an element at an index, or `None` if the index is out of bounds - fn idx(&mut self, index: uint) -> Option< ::Item>; + fn idx(&mut self, index: uint) -> Option; } /// An iterator that knows its exact length @@ -1015,14 +1012,14 @@ pub trait ExactSizeIterator: Iterator { impl ExactSizeIterator for Enumerate where I: ExactSizeIterator {} #[stable] impl ExactSizeIterator for Inspect where - I: ExactSizeIterator + Iterator, + I: ExactSizeIterator, F: FnMut(&A), {} #[stable] impl ExactSizeIterator for Rev where I: ExactSizeIterator + DoubleEndedIterator {} #[stable] impl ExactSizeIterator for Map where - I: ExactSizeIterator + Iterator, + I: ExactSizeIterator, F: FnMut(A) -> B, {} #[stable] @@ -1041,7 +1038,7 @@ impl Iterator for Rev where I: DoubleEndedIterator { type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { self.iter.next_back() } + fn next(&mut self) -> Option<::Item> { self.iter.next_back() } #[inline] fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } } @@ -1049,7 +1046,7 @@ impl Iterator for Rev where I: DoubleEndedIterator { #[stable] impl DoubleEndedIterator for Rev where I: DoubleEndedIterator { #[inline] - fn next_back(&mut self) -> Option< ::Item> { self.iter.next() } + fn next_back(&mut self) -> Option<::Item> { self.iter.next() } } #[experimental = "trait is experimental"] @@ -1057,7 +1054,7 @@ impl RandomAccessIterator for Rev where I: DoubleEndedIterator + RandomAcc #[inline] fn indexable(&self) -> uint { self.iter.indexable() } #[inline] - fn idx(&mut self, index: uint) -> Option< ::Item> { + fn idx(&mut self, index: uint) -> Option<::Item> { let amt = self.indexable(); self.iter.idx(amt - index - 1) } @@ -1075,7 +1072,7 @@ impl<'a, I> Iterator for ByRef<'a, I> where I: 'a + Iterator { type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { self.iter.next() } + fn next(&mut self) -> Option<::Item> { self.iter.next() } #[inline] fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } } @@ -1083,7 +1080,7 @@ impl<'a, I> Iterator for ByRef<'a, I> where I: 'a + Iterator { #[stable] impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterator { #[inline] - fn next_back(&mut self) -> Option< ::Item> { self.iter.next_back() } + fn next_back(&mut self) -> Option<::Item> { self.iter.next_back() } } /// A trait for iterators over elements which can be added together @@ -1244,7 +1241,7 @@ impl Iterator for Cloned where impl DoubleEndedIterator for Cloned where T: Clone, D: Deref, - I: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, { fn next_back(&mut self) -> Option { self.it.next_back().cloned() @@ -1255,7 +1252,7 @@ impl DoubleEndedIterator for Cloned where impl ExactSizeIterator for Cloned where T: Clone, D: Deref, - I: ExactSizeIterator + Iterator, + I: ExactSizeIterator, {} /// An iterator that repeats endlessly @@ -1272,7 +1269,7 @@ impl Iterator for Cycle where I: Clone + Iterator { type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { + fn next(&mut self) -> Option<::Item> { match self.iter.next() { None => { self.iter = self.orig.clone(); self.iter.next() } y => y @@ -1304,7 +1301,7 @@ impl RandomAccessIterator for Cycle where } #[inline] - fn idx(&mut self, index: uint) -> Option< ::Item> { + fn idx(&mut self, index: uint) -> Option<::Item> { let liter = self.iter.indexable(); let lorig = self.orig.indexable(); if lorig == 0 { @@ -1363,8 +1360,8 @@ impl Iterator for Chain where A: Iterator, B: Iterator DoubleEndedIterator for Chain where - A: DoubleEndedIterator + Iterator, - B: DoubleEndedIterator + Iterator, + A: DoubleEndedIterator, + B: DoubleEndedIterator, { #[inline] fn next_back(&mut self) -> Option { @@ -1377,8 +1374,8 @@ impl DoubleEndedIterator for Chain where #[experimental = "trait is experimental"] impl RandomAccessIterator for Chain where - A: RandomAccessIterator + Iterator, - B: RandomAccessIterator + Iterator, + A: RandomAccessIterator, + B: RandomAccessIterator, { #[inline] fn indexable(&self) -> uint { @@ -1444,8 +1441,8 @@ impl Iterator for Zip where #[stable] impl DoubleEndedIterator for Zip where - A: ExactSizeIterator + Iterator + DoubleEndedIterator, - B: ExactSizeIterator + Iterator + DoubleEndedIterator, + A: DoubleEndedIterator + ExactSizeIterator, + B: DoubleEndedIterator + ExactSizeIterator, { #[inline] fn next_back(&mut self) -> Option<(T, U)> { @@ -1469,8 +1466,8 @@ impl DoubleEndedIterator for Zip where #[experimental = "trait is experimental"] impl RandomAccessIterator for Zip where - A: RandomAccessIterator + Iterator, - B: RandomAccessIterator + Iterator, + A: RandomAccessIterator, + B: RandomAccessIterator, { #[inline] fn indexable(&self) -> uint { @@ -1539,7 +1536,7 @@ impl Iterator for Map where I: Iterator, F: FnMu #[stable] impl DoubleEndedIterator for Map where - I: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, F: FnMut(A) -> B, { #[inline] @@ -1551,7 +1548,7 @@ impl DoubleEndedIterator for Map where #[experimental = "trait is experimental"] impl RandomAccessIterator for Map where - I: RandomAccessIterator + Iterator, + I: RandomAccessIterator, F: FnMut(A) -> B, { #[inline] @@ -1613,7 +1610,7 @@ impl Iterator for Filter where I: Iterator, P: FnMut(& #[stable] impl DoubleEndedIterator for Filter where - I: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, P: FnMut(&A) -> bool, { #[inline] @@ -1676,7 +1673,7 @@ impl Iterator for FilterMap where #[stable] impl DoubleEndedIterator for FilterMap where - I: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, F: FnMut(A) -> Option, { #[inline] @@ -1925,7 +1922,7 @@ impl Iterator for Skip where I: Iterator { type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { + fn next(&mut self) -> Option<::Item> { let mut next = self.iter.next(); if self.n == 0 { next @@ -1972,7 +1969,7 @@ impl RandomAccessIterator for Skip where I: RandomAccessIterator{ } #[inline] - fn idx(&mut self, index: uint) -> Option< ::Item> { + fn idx(&mut self, index: uint) -> Option<::Item> { if index >= self.indexable() { None } else { @@ -1995,7 +1992,7 @@ impl Iterator for Take where I: Iterator{ type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { + fn next(&mut self) -> Option<::Item> { if self.n != 0 { self.n -= 1; self.iter.next() @@ -2027,7 +2024,7 @@ impl RandomAccessIterator for Take where I: RandomAccessIterator{ } #[inline] - fn idx(&mut self, index: uint) -> Option< ::Item> { + fn idx(&mut self, index: uint) -> Option<::Item> { if index >= self.n { None } else { @@ -2153,8 +2150,8 @@ impl Iterator for FlatMap where #[stable] impl DoubleEndedIterator for FlatMap where - I: DoubleEndedIterator + Iterator, - U: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, + U: DoubleEndedIterator, F: FnMut(A) -> U, { #[inline] @@ -2189,7 +2186,7 @@ impl Iterator for Fuse where I: Iterator { type Item = ::Item; #[inline] - fn next(&mut self) -> Option< ::Item> { + fn next(&mut self) -> Option<::Item> { if self.done { None } else { @@ -2216,7 +2213,7 @@ impl Iterator for Fuse where I: Iterator { #[stable] impl DoubleEndedIterator for Fuse where I: DoubleEndedIterator { #[inline] - fn next_back(&mut self) -> Option< ::Item> { + fn next_back(&mut self) -> Option<::Item> { if self.done { None } else { @@ -2240,7 +2237,7 @@ impl RandomAccessIterator for Fuse where I: RandomAccessIterator { } #[inline] - fn idx(&mut self, index: uint) -> Option< ::Item> { + fn idx(&mut self, index: uint) -> Option<::Item> { self.iter.idx(index) } } @@ -2308,7 +2305,7 @@ impl Iterator for Inspect where I: Iterator, F: FnMut( #[stable] impl DoubleEndedIterator for Inspect where - I: DoubleEndedIterator + Iterator, + I: DoubleEndedIterator, F: FnMut(&A), { #[inline] @@ -2320,7 +2317,7 @@ impl DoubleEndedIterator for Inspect where #[experimental = "trait is experimental"] impl RandomAccessIterator for Inspect where - I: RandomAccessIterator + Iterator, + I: RandomAccessIterator, F: FnMut(&A), { #[inline] diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 97d94e73bb33a..aa3131077ebe8 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -1134,7 +1134,7 @@ impl<'a, T: ?Sized> Deref for &'a mut T { pub trait DerefMut: Deref { /// The method called to mutably dereference a value #[stable] - fn deref_mut<'a>(&'a mut self) -> &'a mut ::Target; + fn deref_mut<'a>(&'a mut self) -> &'a mut Self::Target; } #[stable] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 093ed0b242f5f..7920e6ed77317 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -873,7 +873,7 @@ impl<'a, T> ExactSizeIterator for IterMut<'a, T> {} trait SplitIter: DoubleEndedIterator { /// Mark the underlying iterator as complete, extracting the remaining /// portion of the slice. - fn finish(&mut self) -> Option< ::Item>; + fn finish(&mut self) -> Option; } /// An iterator over subslices separated by elements that match a predicate @@ -1038,7 +1038,7 @@ struct GenericSplitN { invert: bool } -impl> Iterator for GenericSplitN { +impl> Iterator for GenericSplitN { type Item = T; #[inline] diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs index a04f67f765108..3b76f207c64ff 100644 --- a/src/libserialize/serialize.rs +++ b/src/libserialize/serialize.rs @@ -610,8 +610,8 @@ impl Decodable for Arc { pub trait EncoderHelpers: Encoder { fn emit_from_vec(&mut self, v: &[T], f: F) - -> Result<(), ::Error> - where F: FnMut(&mut Self, &T) -> Result<(), ::Error>; + -> Result<(), Self::Error> + where F: FnMut(&mut Self, &T) -> Result<(), Self::Error>; } impl EncoderHelpers for S { @@ -631,8 +631,8 @@ impl EncoderHelpers for S { pub trait DecoderHelpers: Decoder { fn read_to_vec(&mut self, f: F) - -> Result, ::Error> where - F: FnMut(&mut Self) -> Result::Error>; + -> Result, Self::Error> where + F: FnMut(&mut Self) -> Result; } impl DecoderHelpers for D { From 6680c9c5c797101fc5e0608cb2c3657517333148 Mon Sep 17 00:00:00 2001 From: Corey Richardson Date: Fri, 2 Jan 2015 16:41:24 -0500 Subject: [PATCH 12/49] syntax: implement 'macro input future proofing' See RFC 550 (https://github.com/rust-lang/rfcs/pull/550) for the motivation and details. If this breaks your code, add one of the listed tokens after the relevant non-terminal in your matcher. [breaking-change] --- src/libsyntax/ext/tt/macro_rules.rs | 148 +++++++++++++++++- src/libsyntax/parse/token.rs | 1 + .../macro-input-future-proofing.rs | 26 +++ 3 files changed, 167 insertions(+), 8 deletions(-) create mode 100644 src/test/compile-fail/macro-input-future-proofing.rs diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 9837c8088fa45..96a0f7de0fdc8 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -1,4 +1,4 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use ast::{Ident, TtDelimited, TtSequence, TtToken}; +use ast::{TokenTree, TtDelimited, TtSequence, TtToken}; use ast; use codemap::{Span, DUMMY_SP}; use ext::base::{ExtCtxt, MacResult, SyntaxExtension}; @@ -19,8 +19,8 @@ use ext::tt::macro_parser::{parse, parse_or_else}; use parse::lexer::new_tt_reader; use parse::parser::Parser; use parse::attr::ParserAttr; -use parse::token::{special_idents, gensym_ident}; -use parse::token::{MatchNt, NtTT}; +use parse::token::{special_idents, gensym_ident, NtTT, Token}; +use parse::token::Token::*; use parse::token; use print; use ptr::P; @@ -109,8 +109,8 @@ impl<'a> MacResult for ParserAnyMacro<'a> { } struct MacroRulesMacroExpander { - name: Ident, - imported_from: Option, + name: ast::Ident, + imported_from: Option, lhses: Vec>, rhses: Vec>, } @@ -134,8 +134,8 @@ impl TTMacroExpander for MacroRulesMacroExpander { /// Given `lhses` and `rhses`, this is the new macro we create fn generic_extension<'cx>(cx: &'cx ExtCtxt, sp: Span, - name: Ident, - imported_from: Option, + name: ast::Ident, + imported_from: Option, arg: &[ast::TokenTree], lhses: &[Rc], rhses: &[Rc]) @@ -260,6 +260,10 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt, _ => cx.span_bug(def.span, "wrong-structured lhs") }; + for lhs in lhses.iter() { + check_lhs_nt_follows(cx, &**lhs, def.span); + } + let rhses = match *argument_map[rhs_nm] { MatchedSeq(ref s, _) => /* FIXME (#2543) */ (*s).clone(), _ => cx.span_bug(def.span, "wrong-structured rhs") @@ -274,3 +278,131 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt, NormalTT(exp, Some(def.span)) } + +fn check_lhs_nt_follows(cx: &mut ExtCtxt, lhs: &NamedMatch, sp: Span) { + // lhs is going to be like MatchedNonterminal(NtTT(TtDelimited(...))), where + // the entire lhs is those tts. + // if ever we get box/deref patterns, this could turn into an `if let + // &MatchedNonterminal(NtTT(box TtDelimited(...))) = lhs` + let matcher = match lhs { + &MatchedNonterminal(NtTT(ref inner)) => match &**inner { + &TtDelimited(_, ref tts) => tts.tts[], + _ => cx.span_bug(sp, "wrong-structured lhs for follow check") + }, + _ => cx.span_bug(sp, "wrong-structured lhs for follow check") + }; + + check_matcher(cx, matcher, &Eof); + // we don't abort on errors on rejection, the driver will do that for us + // after parsing/expansion. we can report every error in every macro this way. +} + +fn check_matcher(cx: &mut ExtCtxt, matcher: &[TokenTree], follow: &Token) { + use print::pprust::token_to_string; + + // 1. If there are no tokens in M, accept + if matcher.is_empty() { + return; + } + + // 2. For each token T in M: + let mut tokens = matcher.iter().peekable(); + while let Some(token) = tokens.next() { + match *token { + TtToken(sp, MatchNt(ref name, ref frag_spec, _, _)) => { + // ii. If T is a simple NT, look ahead to the next token T' in + // M. + let next_token = match tokens.peek() { + // If T' closes a complex NT, replace T' with F + Some(&&TtToken(_, CloseDelim(_))) => follow, + Some(&&TtToken(_, ref tok)) => tok, + // T' is any NT (this catches complex NTs, the next + // iteration will die if it's a TtDelimited). + Some(_) => continue, + // else, we're at the end of the macro or sequence + None => follow + }; + + // If T' is in the set FOLLOW(NT), continue. Else, reject. + match *next_token { + Eof | MatchNt(..) => continue, + _ if is_in_follow(cx, next_token, frag_spec.as_str()) => continue, + ref tok => cx.span_err(sp, format!("`${0}:{1}` is followed by `{2}`, which \ + is not allowed for `{1}` fragments", + name.as_str(), frag_spec.as_str(), + token_to_string(tok))[]) + } + }, + TtSequence(_, ref seq) => { + // iii. Else, T is a complex NT. + match seq.separator { + // If T has the form $(...)U+ or $(...)U* for some token U, + // run the algorithm on the contents with F set to U. If it + // accepts, continue, else, reject. + Some(ref u) => check_matcher(cx, seq.tts[], u), + // If T has the form $(...)+ or $(...)*, run the algorithm + // on the contents with F set to EOF. If it accepts, + // continue, else, reject. + None => check_matcher(cx, seq.tts[], &Eof) + } + }, + TtToken(..) => { + // i. If T is not an NT, continue. + continue + }, + TtDelimited(_, ref tts) => { + // if we don't pass in that close delimiter, we'll incorrectly consider the matcher + // `{ $foo:ty }` as having a follow that isn't `}` + check_matcher(cx, tts.tts[], &tts.close_token()) + } + } + } +} + +fn is_in_follow(cx: &ExtCtxt, tok: &Token, frag: &str) -> bool { + if let &CloseDelim(_) = tok { + return true; + } + + match frag { + "item" => { + // since items *must* be followed by either a `;` or a `}`, we can + // accept anything after them + true + }, + "block" => { + // anything can follow block, the braces provide a easy boundary to + // maintain + true + }, + "stmt" | "expr" => { + match *tok { + Comma | Semi => true, + _ => false + } + }, + "pat" => { + match *tok { + FatArrow | Comma | Eq => true, + _ => false + } + }, + "path" | "ty" => { + match *tok { + Comma | RArrow | Colon | Eq | Gt => true, + Ident(i, _) if i.as_str() == "as" => true, + _ => false + } + }, + "ident" => { + // being a single token, idents are harmless + true + }, + "meta" | "tt" => { + // being either a single token or a delimited sequence, tt is + // harmless + true + }, + _ => cx.bug(format!("unrecognized builtin nonterminal {}", frag)[]), + } +} diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 094aacf3207fc..205589ba78ead 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -392,6 +392,7 @@ impl fmt::Show for Nonterminal { } } + // Get the first "argument" macro_rules! first { ( $first:expr, $( $remainder:expr, )* ) => ( $first ) diff --git a/src/test/compile-fail/macro-input-future-proofing.rs b/src/test/compile-fail/macro-input-future-proofing.rs new file mode 100644 index 0000000000000..2804fc1479626 --- /dev/null +++ b/src/test/compile-fail/macro-input-future-proofing.rs @@ -0,0 +1,26 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +macro_rules! errors_everywhere { + ($ty:ty <) => () //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` fragments + ($ty:ty < foo ,) => () //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` + ($ty:ty , ) => () + ( ( $ty:ty ) ) => () + ( { $ty:ty } ) => () + ( [ $ty:ty ] ) => () + ($bl:block < ) => () + ($pa:pat >) => () //~ ERROR `$pa:pat` is followed by `>` which is not allowed for `pat` + ($pa:pat , ) => () + ($pa:pat | ) => () + ($pa:pat $pb:pat $ty:ty ,) => () + ($($ty:ty)-+) => () //~ ERROR `$ty:ty` is followed by `-` which is not allowed for `ty` +} + +fn main() { } From e0b4287df6635158043e7015d89b619af7f7748d Mon Sep 17 00:00:00 2001 From: Corey Richardson Date: Mon, 5 Jan 2015 01:51:03 -0500 Subject: [PATCH 13/49] Fix fallout --- src/doc/guide-macros.md | 36 +-- src/libcore/str/mod.rs | 21 +- src/librustc_trans/trans/context.rs | 220 +++++++++--------- src/libstd/sys/common/backtrace.rs | 28 +-- .../macro-input-future-proofing.rs | 24 +- src/test/run-pass/const-polymorphic-paths.rs | 51 ++-- .../nullable-pointer-iotareduction.rs | 22 +- 7 files changed, 200 insertions(+), 202 deletions(-) diff --git a/src/doc/guide-macros.md b/src/doc/guide-macros.md index dc6d281307a7a..9cb4d154de7b2 100644 --- a/src/doc/guide-macros.md +++ b/src/doc/guide-macros.md @@ -161,7 +161,7 @@ instead of `*` to mean "at least one". # let input_1 = T::SpecialA(0); # let input_2 = T::SpecialA(0); macro_rules! early_return { - ($inp:expr, [ $($sp:path)|+ ]) => ( + ($inp:expr, [ $($sp:path),+ ]) => ( match $inp { $( $sp(x) => { return x; } @@ -171,7 +171,7 @@ macro_rules! early_return { ) } // ... -early_return!(input_1, [T::SpecialA|T::SpecialC|T::SpecialD]); +early_return!(input_1, [T::SpecialA,T::SpecialC,T::SpecialD]); // ... early_return!(input_2, [T::SpecialB]); # return 0; @@ -245,7 +245,7 @@ can solve the problem: ~~~~ macro_rules! biased_match { // special case: `let (x) = ...` is illegal, so use `let x = ...` instead - ( ($e:expr) ~ ($p:pat) else $err:stmt ; + ( ($e:expr) -> ($p:pat) else $err:stmt ; binds $bind_res:ident ) => ( let $bind_res = match $e { @@ -254,7 +254,7 @@ macro_rules! biased_match { }; ); // more than one name; use a tuple - ( ($e:expr) ~ ($p:pat) else $err:stmt ; + ( ($e:expr) -> ($p:pat) else $err:stmt ; binds $( $bind_res:ident ),* ) => ( let ( $( $bind_res ),* ) = match $e { @@ -268,9 +268,9 @@ macro_rules! biased_match { # struct T2 { body: T3 } # enum T3 { Good2(uint), Bad2} # fn f(x: T1) -> uint { -biased_match!((x) ~ (T1::Good1(g1, val)) else { return 0 }; +biased_match!((x) -> (T1::Good1(g1, val)) else { return 0 }; binds g1, val ); -biased_match!((g1.body) ~ (T3::Good2(result) ) +biased_match!((g1.body) -> (T3::Good2(result) ) else { panic!("Didn't get good_2") }; binds result ); // complicated stuff goes here @@ -286,7 +286,7 @@ pattern we want is clear: ~~~~ # fn main() {} # macro_rules! b { - ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )* + ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )* binds $( $bind_res:ident ),* ) # => (0) } @@ -317,8 +317,8 @@ input patterns: ~~~~ # fn main() {} # macro_rules! b { - ( ($e :expr) ~ ($p :pat) else $err :stmt ; - $( ($e_rest:expr) ~ ($p_rest:pat) else $err_rest:stmt ; )* + ( ($e :expr) -> ($p :pat) else $err :stmt ; + $( ($e_rest:expr) -> ($p_rest:pat) else $err_rest:stmt ; )* binds $( $bind_res:ident ),* ) # => (0) } @@ -333,14 +333,14 @@ piece of syntax (the `let`) which we only want to transcribe once. macro_rules! biased_match_rec { // Handle the first layer - ( ($e :expr) ~ ($p :pat) else $err :stmt ; - $( ($e_rest:expr) ~ ($p_rest:pat) else $err_rest:stmt ; )* + ( ($e :expr) -> ($p :pat) else $err :stmt ; + $( ($e_rest:expr) -> ($p_rest:pat) else $err_rest:stmt ; )* binds $( $bind_res:ident ),* ) => ( match $e { $p => { // Recursively handle the next layer - biased_match_rec!($( ($e_rest) ~ ($p_rest) else $err_rest ; )* + biased_match_rec!($( ($e_rest) -> ($p_rest) else $err_rest ; )* binds $( $bind_res ),* ) } @@ -354,20 +354,20 @@ macro_rules! biased_match_rec { // Wrap the whole thing in a `let`. macro_rules! biased_match { // special case: `let (x) = ...` is illegal, so use `let x = ...` instead - ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )* + ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )* binds $bind_res:ident ) => ( let $bind_res = biased_match_rec!( - $( ($e) ~ ($p) else $err ; )* + $( ($e) -> ($p) else $err ; )* binds $bind_res ); ); // more than one name: use a tuple - ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )* + ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )* binds $( $bind_res:ident ),* ) => ( let ( $( $bind_res ),* ) = biased_match_rec!( - $( ($e) ~ ($p) else $err ; )* + $( ($e) -> ($p) else $err ; )* binds $( $bind_res ),* ); ) @@ -379,8 +379,8 @@ macro_rules! biased_match { # enum T3 { Good2(uint), Bad2} # fn f(x: T1) -> uint { biased_match!( - (x) ~ (T1::Good1(g1, val)) else { return 0 }; - (g1.body) ~ (T3::Good2(result) ) else { panic!("Didn't get Good2") }; + (x) -> (T1::Good1(g1, val)) else { return 0 }; + (g1.body) -> (T3::Good2(result) ) else { panic!("Didn't get Good2") }; binds val, result ); // complicated stuff goes here return result + val; diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a39787b8207b5..b0a1fa0b1b4c6 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -35,9 +35,8 @@ use slice::{self, SliceExt}; use uint; macro_rules! delegate_iter { - (exact $te:ty in $ti:ty) => { - delegate_iter!{$te in $ti} - #[stable] + (exact $te:ty : $ti:ty) => { + delegate_iter!{$te : $ti} impl<'a> ExactSizeIterator for $ti { #[inline] fn len(&self) -> uint { @@ -45,7 +44,7 @@ macro_rules! delegate_iter { } } }; - ($te:ty in $ti:ty) => { + ($te:ty : $ti:ty) => { #[stable] impl<'a> Iterator for $ti { type Item = $te; @@ -67,7 +66,7 @@ macro_rules! delegate_iter { } } }; - (pattern $te:ty in $ti:ty) => { + (pattern $te:ty : $ti:ty) => { #[stable] impl<'a, P: CharEq> Iterator for $ti { type Item = $te; @@ -89,7 +88,7 @@ macro_rules! delegate_iter { } } }; - (pattern forward $te:ty in $ti:ty) => { + (pattern forward $te:ty : $ti:ty) => { #[stable] impl<'a, P: CharEq> Iterator for $ti { type Item = $te; @@ -415,7 +414,7 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> { #[stable] #[derive(Clone)] pub struct Bytes<'a>(Map<&'a u8, u8, slice::Iter<'a, u8>, BytesDeref>); -delegate_iter!{exact u8 in Bytes<'a>} +delegate_iter!{exact u8 : Bytes<'a>} /// A temporary fn new type that ensures that the `Bytes` iterator /// is cloneable. @@ -1165,25 +1164,25 @@ impl<'a, S: ?Sized> Str for &'a S where S: Str { #[derive(Clone)] #[stable] pub struct Split<'a, P>(CharSplits<'a, P>); -delegate_iter!{pattern &'a str in Split<'a, P>} +delegate_iter!{pattern &'a str : Split<'a, P>} /// Return type of `StrExt::split_terminator` #[derive(Clone)] #[unstable = "might get removed in favour of a constructor method on Split"] pub struct SplitTerminator<'a, P>(CharSplits<'a, P>); -delegate_iter!{pattern &'a str in SplitTerminator<'a, P>} +delegate_iter!{pattern &'a str : SplitTerminator<'a, P>} /// Return type of `StrExt::splitn` #[derive(Clone)] #[stable] pub struct SplitN<'a, P>(CharSplitsN<'a, P>); -delegate_iter!{pattern forward &'a str in SplitN<'a, P>} +delegate_iter!{pattern forward &'a str : SplitN<'a, P>} /// Return type of `StrExt::rsplitn` #[derive(Clone)] #[stable] pub struct RSplitN<'a, P>(CharSplitsN<'a, P>); -delegate_iter!{pattern forward &'a str in RSplitN<'a, P>} +delegate_iter!{pattern forward &'a str : RSplitN<'a, P>} /// Methods for string slices #[allow(missing_docs)] diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs index 3726cf14023ee..bced3be01f0d6 100644 --- a/src/librustc_trans/trans/context.rs +++ b/src/librustc_trans/trans/context.rs @@ -737,7 +737,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option { macro_rules! ifn { - ($name:expr fn() -> $ret:expr) => ( + ($name:expr, fn() -> $ret:expr) => ( if *key == $name { let f = base::decl_cdecl_fn( ccx, $name, Type::func(&[], &$ret), @@ -746,7 +746,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option $ret:expr) => ( + ($name:expr, fn($($arg:expr),*) -> $ret:expr) => ( if *key == $name { let f = base::decl_cdecl_fn(ccx, $name, Type::func(&[$($arg),*], &$ret), ty::mk_nil(ccx.tcx())); @@ -769,111 +769,111 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option void); - ifn!("llvm.memcpy.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void); - ifn!("llvm.memmove.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void); - ifn!("llvm.memmove.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void); - ifn!("llvm.memset.p0i8.i32" fn(i8p, t_i8, t_i32, t_i32, i1) -> void); - ifn!("llvm.memset.p0i8.i64" fn(i8p, t_i8, t_i64, t_i32, i1) -> void); - - ifn!("llvm.trap" fn() -> void); - ifn!("llvm.debugtrap" fn() -> void); - ifn!("llvm.frameaddress" fn(t_i32) -> i8p); - - ifn!("llvm.powi.f32" fn(t_f32, t_i32) -> t_f32); - ifn!("llvm.powi.f64" fn(t_f64, t_i32) -> t_f64); - ifn!("llvm.pow.f32" fn(t_f32, t_f32) -> t_f32); - ifn!("llvm.pow.f64" fn(t_f64, t_f64) -> t_f64); - - ifn!("llvm.sqrt.f32" fn(t_f32) -> t_f32); - ifn!("llvm.sqrt.f64" fn(t_f64) -> t_f64); - ifn!("llvm.sin.f32" fn(t_f32) -> t_f32); - ifn!("llvm.sin.f64" fn(t_f64) -> t_f64); - ifn!("llvm.cos.f32" fn(t_f32) -> t_f32); - ifn!("llvm.cos.f64" fn(t_f64) -> t_f64); - ifn!("llvm.exp.f32" fn(t_f32) -> t_f32); - ifn!("llvm.exp.f64" fn(t_f64) -> t_f64); - ifn!("llvm.exp2.f32" fn(t_f32) -> t_f32); - ifn!("llvm.exp2.f64" fn(t_f64) -> t_f64); - ifn!("llvm.log.f32" fn(t_f32) -> t_f32); - ifn!("llvm.log.f64" fn(t_f64) -> t_f64); - ifn!("llvm.log10.f32" fn(t_f32) -> t_f32); - ifn!("llvm.log10.f64" fn(t_f64) -> t_f64); - ifn!("llvm.log2.f32" fn(t_f32) -> t_f32); - ifn!("llvm.log2.f64" fn(t_f64) -> t_f64); - - ifn!("llvm.fma.f32" fn(t_f32, t_f32, t_f32) -> t_f32); - ifn!("llvm.fma.f64" fn(t_f64, t_f64, t_f64) -> t_f64); - - ifn!("llvm.fabs.f32" fn(t_f32) -> t_f32); - ifn!("llvm.fabs.f64" fn(t_f64) -> t_f64); - - ifn!("llvm.floor.f32" fn(t_f32) -> t_f32); - ifn!("llvm.floor.f64" fn(t_f64) -> t_f64); - ifn!("llvm.ceil.f32" fn(t_f32) -> t_f32); - ifn!("llvm.ceil.f64" fn(t_f64) -> t_f64); - ifn!("llvm.trunc.f32" fn(t_f32) -> t_f32); - ifn!("llvm.trunc.f64" fn(t_f64) -> t_f64); - - ifn!("llvm.rint.f32" fn(t_f32) -> t_f32); - ifn!("llvm.rint.f64" fn(t_f64) -> t_f64); - ifn!("llvm.nearbyint.f32" fn(t_f32) -> t_f32); - ifn!("llvm.nearbyint.f64" fn(t_f64) -> t_f64); - - ifn!("llvm.ctpop.i8" fn(t_i8) -> t_i8); - ifn!("llvm.ctpop.i16" fn(t_i16) -> t_i16); - ifn!("llvm.ctpop.i32" fn(t_i32) -> t_i32); - ifn!("llvm.ctpop.i64" fn(t_i64) -> t_i64); - - ifn!("llvm.ctlz.i8" fn(t_i8 , i1) -> t_i8); - ifn!("llvm.ctlz.i16" fn(t_i16, i1) -> t_i16); - ifn!("llvm.ctlz.i32" fn(t_i32, i1) -> t_i32); - ifn!("llvm.ctlz.i64" fn(t_i64, i1) -> t_i64); - - ifn!("llvm.cttz.i8" fn(t_i8 , i1) -> t_i8); - ifn!("llvm.cttz.i16" fn(t_i16, i1) -> t_i16); - ifn!("llvm.cttz.i32" fn(t_i32, i1) -> t_i32); - ifn!("llvm.cttz.i64" fn(t_i64, i1) -> t_i64); - - ifn!("llvm.bswap.i16" fn(t_i16) -> t_i16); - ifn!("llvm.bswap.i32" fn(t_i32) -> t_i32); - ifn!("llvm.bswap.i64" fn(t_i64) -> t_i64); - - ifn!("llvm.sadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.sadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.sadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.sadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.uadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.uadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.uadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.uadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.ssub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.ssub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.ssub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.ssub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.usub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.usub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.usub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.usub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.smul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.smul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.smul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.smul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.umul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); - ifn!("llvm.umul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); - ifn!("llvm.umul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); - ifn!("llvm.umul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); - - ifn!("llvm.lifetime.start" fn(t_i64,i8p) -> void); - ifn!("llvm.lifetime.end" fn(t_i64, i8p) -> void); - - ifn!("llvm.expect.i1" fn(i1, i1) -> i1); - ifn!("llvm.assume" fn(i1) -> void); + ifn!("llvm.memcpy.p0i8.p0i8.i32", fn(i8p, i8p, t_i32, t_i32, i1) -> void); + ifn!("llvm.memcpy.p0i8.p0i8.i64", fn(i8p, i8p, t_i64, t_i32, i1) -> void); + ifn!("llvm.memmove.p0i8.p0i8.i32", fn(i8p, i8p, t_i32, t_i32, i1) -> void); + ifn!("llvm.memmove.p0i8.p0i8.i64", fn(i8p, i8p, t_i64, t_i32, i1) -> void); + ifn!("llvm.memset.p0i8.i32", fn(i8p, t_i8, t_i32, t_i32, i1) -> void); + ifn!("llvm.memset.p0i8.i64", fn(i8p, t_i8, t_i64, t_i32, i1) -> void); + + ifn!("llvm.trap", fn() -> void); + ifn!("llvm.debugtrap", fn() -> void); + ifn!("llvm.frameaddress", fn(t_i32) -> i8p); + + ifn!("llvm.powi.f32", fn(t_f32, t_i32) -> t_f32); + ifn!("llvm.powi.f64", fn(t_f64, t_i32) -> t_f64); + ifn!("llvm.pow.f32", fn(t_f32, t_f32) -> t_f32); + ifn!("llvm.pow.f64", fn(t_f64, t_f64) -> t_f64); + + ifn!("llvm.sqrt.f32", fn(t_f32) -> t_f32); + ifn!("llvm.sqrt.f64", fn(t_f64) -> t_f64); + ifn!("llvm.sin.f32", fn(t_f32) -> t_f32); + ifn!("llvm.sin.f64", fn(t_f64) -> t_f64); + ifn!("llvm.cos.f32", fn(t_f32) -> t_f32); + ifn!("llvm.cos.f64", fn(t_f64) -> t_f64); + ifn!("llvm.exp.f32", fn(t_f32) -> t_f32); + ifn!("llvm.exp.f64", fn(t_f64) -> t_f64); + ifn!("llvm.exp2.f32", fn(t_f32) -> t_f32); + ifn!("llvm.exp2.f64", fn(t_f64) -> t_f64); + ifn!("llvm.log.f32", fn(t_f32) -> t_f32); + ifn!("llvm.log.f64", fn(t_f64) -> t_f64); + ifn!("llvm.log10.f32", fn(t_f32) -> t_f32); + ifn!("llvm.log10.f64", fn(t_f64) -> t_f64); + ifn!("llvm.log2.f32", fn(t_f32) -> t_f32); + ifn!("llvm.log2.f64", fn(t_f64) -> t_f64); + + ifn!("llvm.fma.f32", fn(t_f32, t_f32, t_f32) -> t_f32); + ifn!("llvm.fma.f64", fn(t_f64, t_f64, t_f64) -> t_f64); + + ifn!("llvm.fabs.f32", fn(t_f32) -> t_f32); + ifn!("llvm.fabs.f64", fn(t_f64) -> t_f64); + + ifn!("llvm.floor.f32", fn(t_f32) -> t_f32); + ifn!("llvm.floor.f64", fn(t_f64) -> t_f64); + ifn!("llvm.ceil.f32", fn(t_f32) -> t_f32); + ifn!("llvm.ceil.f64", fn(t_f64) -> t_f64); + ifn!("llvm.trunc.f32", fn(t_f32) -> t_f32); + ifn!("llvm.trunc.f64", fn(t_f64) -> t_f64); + + ifn!("llvm.rint.f32", fn(t_f32) -> t_f32); + ifn!("llvm.rint.f64", fn(t_f64) -> t_f64); + ifn!("llvm.nearbyint.f32", fn(t_f32) -> t_f32); + ifn!("llvm.nearbyint.f64", fn(t_f64) -> t_f64); + + ifn!("llvm.ctpop.i8", fn(t_i8) -> t_i8); + ifn!("llvm.ctpop.i16", fn(t_i16) -> t_i16); + ifn!("llvm.ctpop.i32", fn(t_i32) -> t_i32); + ifn!("llvm.ctpop.i64", fn(t_i64) -> t_i64); + + ifn!("llvm.ctlz.i8", fn(t_i8 , i1) -> t_i8); + ifn!("llvm.ctlz.i16", fn(t_i16, i1) -> t_i16); + ifn!("llvm.ctlz.i32", fn(t_i32, i1) -> t_i32); + ifn!("llvm.ctlz.i64", fn(t_i64, i1) -> t_i64); + + ifn!("llvm.cttz.i8", fn(t_i8 , i1) -> t_i8); + ifn!("llvm.cttz.i16", fn(t_i16, i1) -> t_i16); + ifn!("llvm.cttz.i32", fn(t_i32, i1) -> t_i32); + ifn!("llvm.cttz.i64", fn(t_i64, i1) -> t_i64); + + ifn!("llvm.bswap.i16", fn(t_i16) -> t_i16); + ifn!("llvm.bswap.i32", fn(t_i32) -> t_i32); + ifn!("llvm.bswap.i64", fn(t_i64) -> t_i64); + + ifn!("llvm.sadd.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.sadd.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.sadd.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.sadd.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.uadd.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.uadd.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.uadd.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.uadd.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.ssub.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.ssub.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.ssub.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.ssub.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.usub.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.usub.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.usub.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.usub.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.smul.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.smul.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.smul.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.smul.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.umul.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1}); + ifn!("llvm.umul.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1}); + ifn!("llvm.umul.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1}); + ifn!("llvm.umul.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1}); + + ifn!("llvm.lifetime.start", fn(t_i64,i8p) -> void); + ifn!("llvm.lifetime.end", fn(t_i64, i8p) -> void); + + ifn!("llvm.expect.i1", fn(i1, i1) -> i1); + ifn!("llvm.assume", fn(i1) -> void); // Some intrinsics were introduced in later versions of LLVM, but they have // fallbacks in libc or libm and such. Currently, all of these intrinsics @@ -882,7 +882,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option $ret:expr) => ( if unsafe { llvm::LLVMVersionMinor() >= 4 } { // The `if key == $name` is already in ifn! - ifn!($name fn($($arg),*) -> $ret); + ifn!($name, fn($($arg),*) -> $ret); } else if *key == $name { let f = base::decl_cdecl_fn(ccx, stringify!($cname), Type::func(&[$($arg),*], &$ret), @@ -900,8 +900,8 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option void); - ifn!("llvm.dbg.value" fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void); + ifn!("llvm.dbg.declare", fn(Type::metadata(ccx), Type::metadata(ccx)) -> void); + ifn!("llvm.dbg.value", fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void); } return None; } diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index d4039fd96ff20..be44aa99f49d7 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -88,7 +88,7 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> { while rest.len() > 0 { if rest.starts_with("$") { macro_rules! demangle { - ($($pat:expr => $demangled:expr),*) => ({ + ($($pat:expr, => $demangled:expr),*) => ({ $(if rest.starts_with($pat) { try!(writer.write_str($demangled)); rest = rest.slice_from($pat.len()); @@ -103,22 +103,22 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> { // see src/librustc/back/link.rs for these mappings demangle! ( - "$SP$" => "@", - "$UP$" => "Box", - "$RP$" => "*", - "$BP$" => "&", - "$LT$" => "<", - "$GT$" => ">", - "$LP$" => "(", - "$RP$" => ")", - "$C$" => ",", + "$SP$", => "@", + "$UP$", => "Box", + "$RP$", => "*", + "$BP$", => "&", + "$LT$", => "<", + "$GT$", => ">", + "$LP$", => "(", + "$RP$", => ")", + "$C$", => ",", // in theory we can demangle any Unicode code point, but // for simplicity we just catch the common ones. - "$u{20}" => " ", - "$u{27}" => "'", - "$u{5b}" => "[", - "$u{5d}" => "]" + "$u{20}", => " ", + "$u{27}", => "'", + "$u{5b}", => "[", + "$u{5d}", => "]" ) } else { let idx = match rest.find('$') { diff --git a/src/test/compile-fail/macro-input-future-proofing.rs b/src/test/compile-fail/macro-input-future-proofing.rs index 2804fc1479626..1f2db6240653d 100644 --- a/src/test/compile-fail/macro-input-future-proofing.rs +++ b/src/test/compile-fail/macro-input-future-proofing.rs @@ -9,18 +9,18 @@ // except according to those terms. macro_rules! errors_everywhere { - ($ty:ty <) => () //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` fragments - ($ty:ty < foo ,) => () //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` - ($ty:ty , ) => () - ( ( $ty:ty ) ) => () - ( { $ty:ty } ) => () - ( [ $ty:ty ] ) => () - ($bl:block < ) => () - ($pa:pat >) => () //~ ERROR `$pa:pat` is followed by `>` which is not allowed for `pat` - ($pa:pat , ) => () - ($pa:pat | ) => () - ($pa:pat $pb:pat $ty:ty ,) => () - ($($ty:ty)-+) => () //~ ERROR `$ty:ty` is followed by `-` which is not allowed for `ty` + ($ty:ty <) => (); //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` + ($ty:ty < foo ,) => (); //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty` + ($ty:ty , ) => (); + ( ( $ty:ty ) ) => (); + ( { $ty:ty } ) => (); + ( [ $ty:ty ] ) => (); + ($bl:block < ) => (); + ($pa:pat >) => (); //~ ERROR `$pa:pat` is followed by `>`, which is not allowed for `pat` + ($pa:pat , ) => (); + ($pa:pat | ) => (); //~ ERROR `$pa:pat` is followed by `|` + ($pa:pat $pb:pat $ty:ty ,) => (); + ($($ty:ty)-+) => (); //~ ERROR `$ty:ty` is followed by `-`, which is not allowed for `ty` } fn main() { } diff --git a/src/test/run-pass/const-polymorphic-paths.rs b/src/test/run-pass/const-polymorphic-paths.rs index 25c1464adfaf4..28b346c9ed4d0 100644 --- a/src/test/run-pass/const-polymorphic-paths.rs +++ b/src/test/run-pass/const-polymorphic-paths.rs @@ -29,7 +29,7 @@ fn odd(x: uint) -> bool { x % 2 == 1 } fn dummy_rng() -> DummyRng { DummyRng::new_unseeded() } macro_rules! tests { - ($($expr:expr: $ty:ty /($($test:expr),*);)+) => (pub fn main() {$({ + ($($expr:expr, $ty:ty, ($($test:expr),*);)+) => (pub fn main() {$({ const C: $ty = $expr; static S: $ty = $expr; assert!(eq(C($($test),*), $expr($($test),*))); @@ -40,45 +40,44 @@ macro_rules! tests { tests! { // Free function. - id: fn(int) -> int /(5); - id::: fn(int) -> int /(5); + id, fn(int) -> int, (5); + id::, fn(int) -> int, (5); // Enum variant constructor. - Some: fn(int) -> Option /(5); - Some::: fn(int) -> Option /(5); + Some, fn(int) -> Option, (5); + Some::, fn(int) -> Option, (5); // Tuple struct constructor. - Newt: fn(int) -> Newt /(5); - Newt::: fn(int) -> Newt /(5); + Newt, fn(int) -> Newt, (5); + Newt::, fn(int) -> Newt, (5); // Inherent static methods. - Vec::new: fn() -> Vec<()> /(); - Vec::<()>::new: fn() -> Vec<()> /(); - Vec::with_capacity: fn(uint) -> Vec<()> /(5); - Vec::<()>::with_capacity: fn(uint) -> Vec<()> /(5); - Bitv::from_fn: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd); - Bitv::from_fn:: bool>: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd); + Vec::new, fn() -> Vec<()>, (); + Vec::<()>::new, fn() -> Vec<()>, (); + Vec::with_capacity, fn(uint) -> Vec<()>, (5); + Vec::<()>::with_capacity, fn(uint) -> Vec<()>, (5); + Bitv::from_fn, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd); + Bitv::from_fn:: bool>, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd); // Inherent non-static method. - Vec::map_in_place: fn(Vec, fn(u8) -> i8) -> Vec - /(vec![b'f', b'o', b'o'], u8_as_i8); - Vec::map_in_place:: i8>: fn(Vec, fn(u8) -> i8) -> Vec - /(vec![b'f', b'o', b'o'], u8_as_i8); + Vec::map_in_place, fn(Vec, fn(u8) -> i8) -> Vec, (vec![b'f', b'o', b'o'], u8_as_i8); + Vec::map_in_place:: i8>, fn(Vec, fn(u8) -> i8) -> Vec, + (vec![b'f', b'o', b'o'], u8_as_i8); // FIXME these break with "type parameter might not appear here pointing at ``. // Vec::::map_in_place: fn(Vec, fn(u8) -> i8) -> Vec - // /(vec![b'f', b'o', b'o'], u8_as_i8); + // , (vec![b'f', b'o', b'o'], u8_as_i8); // Vec::::map_in_place:: i8>: fn(Vec, fn(u8) -> i8) -> Vec - // /(vec![b'f', b'o', b'o'], u8_as_i8); + // , (vec![b'f', b'o', b'o'], u8_as_i8); // Trait static methods. // FIXME qualified path expressions aka UFCS i.e. ::method. - Default::default: fn() -> int /(); - Rand::rand: fn(&mut DummyRng) -> int /(&mut dummy_rng()); - Rand::rand::: fn(&mut DummyRng) -> int /(&mut dummy_rng()); + Default::default, fn() -> int, (); + Rand::rand, fn(&mut DummyRng) -> int, (&mut dummy_rng()); + Rand::rand::, fn(&mut DummyRng) -> int, (&mut dummy_rng()); // Trait non-static methods. - Clone::clone: fn(&int) -> int /(&5); - FromIterator::from_iter: fn(OptionIter) -> Vec /(Some(5).into_iter()); - FromIterator::from_iter::>: fn(OptionIter) -> Vec - /(Some(5).into_iter()); + Clone::clone, fn(&int) -> int, (&5); + FromIterator::from_iter, fn(OptionIter) -> Vec, (Some(5).into_iter()); + FromIterator::from_iter::>, fn(OptionIter) -> Vec + , (Some(5).into_iter()); } diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs index 9b9a7f68995f7..0293c4e36ac59 100644 --- a/src/test/run-pass/nullable-pointer-iotareduction.rs +++ b/src/test/run-pass/nullable-pointer-iotareduction.rs @@ -35,10 +35,10 @@ impl E { } macro_rules! check_option { - ($e:expr: $T:ty) => {{ - check_option!($e: $T, |ptr| assert!(*ptr == $e)); + ($e:expr, $T:ty) => {{ + check_option!($e, $T, |ptr| assert!(*ptr == $e)); }}; - ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{ + ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{ assert!(option::Option::None::<$T>.is_none()); let e = $e; let s_ = option::Option::Some::<$T>(e); @@ -48,10 +48,10 @@ macro_rules! check_option { } macro_rules! check_fancy { - ($e:expr: $T:ty) => {{ - check_fancy!($e: $T, |ptr| assert!(*ptr == $e)); + ($e:expr, $T:ty) => {{ + check_fancy!($e, $T, |ptr| assert!(*ptr == $e)); }}; - ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{ + ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{ assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none()); let e = $e; let t_ = E::Thing::<$T>(23, e); @@ -71,12 +71,12 @@ macro_rules! check_type { } pub fn main() { - check_type!(&17: &int); - check_type!(box 18: Box); - check_type!("foo".to_string(): String); - check_type!(vec!(20, 22): Vec ); + check_type!(&17, &int); + check_type!(box 18, Box); + check_type!("foo".to_string(), String); + check_type!(vec!(20, 22), Vec ); let mint: uint = unsafe { mem::transmute(main) }; - check_type!(main: fn(), |pthing| { + check_type!(main, fn(), |pthing| { assert!(mint == unsafe { mem::transmute(*pthing) }) }); } From f67b81e8d4dc198ad10ad50a7624e43cc1e25802 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Mon, 5 Jan 2015 15:45:18 -0800 Subject: [PATCH 14/49] Stabilize std::thread This commit takes a first pass at stabilizing `std::thread`: * It removes the `detach` method in favor of two constructors -- `spawn` for detached threads, `scoped` for "scoped" (i.e., must-join) threads. This addresses some of the surprise/frustrating debug sessions with the previous API, in which `spawn` produced a guard that on destruction joined the thread (unless `detach` was called). The reason to have the division in part is that `Send` will soon not imply `'static`, which means that `scoped` thread creation can take a closure over *shared stack data* of the parent thread. On the other hand, this means that the parent must not pop the relevant stack frames while the child thread is running. The `JoinGuard` is used to prevent this from happening by joining on drop (if you have not already explicitly `join`ed.) The APIs around `scoped` are future-proofed for the `Send` changes by taking an additional lifetime parameter. With the current definition of `Send`, this is forced to be `'static`, but when `Send` changes these APIs will gain their full flexibility immediately. Threads that are `spawn`ed, on the other hand, are detached from the start and do not yield an RAII guard. The hope is that, by making `scoped` an explicit opt-in with a very suggestive name, it will be drastically less likely to be caught by a surprising deadlock due to an implicit join at the end of a scope. * The module itself is marked stable. * Existing methods other than `spawn` and `scoped` are marked stable. The migration path is: ```rust Thread::spawn(f).detached() ``` becomes ```rust Thread::spawn(f) ``` while ```rust let res = Thread::spawn(f); res.join() ``` becomes ```rust let res = Thread::scoped(f); res.join() ``` [breaking-change] --- src/libstd/thread.rs | 159 +++++++++++++++++++++++++++++++------------ 1 file changed, 115 insertions(+), 44 deletions(-) diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index cc82d38ae2af1..9e12a7b592ae3 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -16,7 +16,7 @@ //! each with their own stack and local state. //! //! Communication between threads can be done through -//! [channels](../../std/comm/index.html), Rust's message-passing +//! [channels](../../std/sync/mpsc/index.html), Rust's message-passing //! types, along with [other forms of thread //! synchronization](../../std/sync/index.html) and shared-memory data //! structures. In particular, types that are guaranteed to be @@ -58,25 +58,45 @@ //! ```rust //! use std::thread::Thread; //! -//! let guard = Thread::spawn(move || { +//! let thread = Thread::spawn(move || { //! println!("Hello, World!"); //! // some computation here //! }); -//! let result = guard.join(); //! ``` //! -//! The `spawn` function doesn't return a `Thread` directly; instead, it returns -//! a *join guard* from which a `Thread` can be extracted. The join guard is an -//! RAII-style guard that will automatically join the child thread (block until -//! it terminates) when it is dropped. You can join the child thread in advance -//! by calling the `join` method on the guard, which will also return the result -//! produced by the thread. +//! The spawned thread is "detached" from the current thread, meaning that it +//! can outlive the thread that spawned it. (Note, however, that when the main +//! thread terminates all detached threads are terminated as well.) The returned +//! `Thread` handle can be used for low-level synchronization as described below. +//! +//! ## Scoped threads +//! +//! Often a parent thread uses a child thread to perform some particular task, +//! and at some point must wait for the child to complete before continuing. +//! For this scenario, use the `scoped` constructor: +//! +//! ```rust +//! use std::thread::Thread; +//! +//! let guard = Thread::scoped(move || { +//! println!("Hello, World!"); +//! // some computation here +//! }); +//! // do some other work in the meantime +//! let result = guard.join(); +//! ``` //! -//! If you instead wish to *detach* the child thread, allowing it to outlive its -//! parent, you can use the `detach` method on the guard, +//! The `scoped` function doesn't return a `Thread` directly; instead, it +//! returns a *join guard* from which a `Thread` can be extracted. The join +//! guard is an RAII-style guard that will automatically join the child thread +//! (block until it terminates) when it is dropped. You can join the child +//! thread in advance by calling the `join` method on the guard, which will also +//! return the result produced by the thread. A handle to the thread itself is +//! available via the `thread` method on the join guard. //! -//! A handle to the thread itself is available via the `thread` method on the -//! join guard. +//! (Note: eventually, the `scoped` constructor will allow the parent and child +//! threads to data that lives on the parent thread's stack, but some language +//! changes are needed before this is possible.) //! //! ## Configuring threads //! @@ -89,7 +109,7 @@ //! //! thread::Builder::new().name("child1".to_string()).spawn(move || { //! println!("Hello, world!") -//! }).detach(); +//! }); //! ``` //! //! ## Blocking support: park and unpark @@ -124,6 +144,8 @@ //! //! * It can be implemented highly efficiently on many platforms. +#![stable] + use any::Any; use boxed::Box; use cell::UnsafeCell; @@ -144,6 +166,7 @@ use sys_common::{stack, thread_info}; /// Thread configuation. Provides detailed control over the properties /// and behavior of new threads. +#[stable] pub struct Builder { // A name for the thread-to-be, for identification in panic messages name: Option, @@ -158,6 +181,7 @@ pub struct Builder { impl Builder { /// Generate the base configuration for spawning a thread, from which /// configuration methods can be chained. + #[stable] pub fn new() -> Builder { Builder { name: None, @@ -169,12 +193,14 @@ impl Builder { /// Name the thread-to-be. Currently the name is used for identification /// only in panic messages. + #[stable] pub fn name(mut self, name: String) -> Builder { self.name = Some(name); self } /// Set the size of the stack for the new thread. + #[stable] pub fn stack_size(mut self, size: uint) -> Builder { self.stack_size = Some(size); self @@ -194,19 +220,41 @@ impl Builder { self } - /// Spawn a new joinable thread, and return a JoinGuard guard for it. + /// Spawn a new detached thread, and return a handle to it. /// /// See `Thead::spawn` and the module doc for more details. - pub fn spawn(self, f: F) -> JoinGuard where - T: Send, F: FnOnce() -> T, F: Send - { - self.spawn_inner(Thunk::new(f)) + #[unstable = "may change with specifics of new Send semantics"] + pub fn spawn(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static { + let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {})); + unsafe { imp::detach(native) }; + thread } - fn spawn_inner(self, f: Thunk<(), T>) -> JoinGuard { + /// Spawn a new child thread that must be joined within a given + /// scope, and return a `JoinGuard`. + /// + /// See `Thead::scoped` and the module doc for more details. + #[unstable = "may change with specifics of new Send semantics"] + pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where + T: Send + 'a, F: FnOnce() -> T, F: Send + 'a + { let my_packet = Packet(Arc::new(UnsafeCell::new(None))); let their_packet = Packet(my_packet.0.clone()); + let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(move |: ret| unsafe { + *their_packet.0.get() = Some(ret); + })); + JoinGuard { + native: native, + joined: false, + packet: my_packet, + thread: thread, + } + } + + fn spawn_inner(self, f: Thunk<(), T>, finish: Thunk, ()>) + -> (imp::rust_thread, Thread) + { let Builder { name, stack_size, stdout, stderr } = self; let stack_size = stack_size.unwrap_or(rt::min_stack()); @@ -258,21 +306,14 @@ impl Builder { unwind::try(move || *ptr = Some(f.invoke(()))) } }; - unsafe { - *their_packet.0.get() = Some(match (output, try_result) { - (Some(data), Ok(_)) => Ok(data), - (None, Err(cause)) => Err(cause), - _ => unreachable!() - }); - } + finish.invoke(match (output, try_result) { + (Some(data), Ok(_)) => Ok(data), + (None, Err(cause)) => Err(cause), + _ => unreachable!() + }); }; - JoinGuard { - native: unsafe { imp::create(stack_size, Thunk::new(main)) }, - joined: false, - packet: my_packet, - thread: my_thread, - } + (unsafe { imp::create(stack_size, Thunk::new(main)) }, my_thread) } } @@ -285,11 +326,13 @@ struct Inner { unsafe impl Sync for Inner {} #[derive(Clone)] +#[stable] /// A handle to a thread. pub struct Thread { inner: Arc, } +#[stable] unsafe impl Sync for Thread {} impl Thread { @@ -304,30 +347,47 @@ impl Thread { } } - /// Spawn a new joinable thread, returning a `JoinGuard` for it. + /// Spawn a new detached thread, returning a handle to it. + /// + /// The child thread may outlive the parent (unless the parent thread is the + /// main thread; the whole process is terminated when the main thread + /// finishes.) The thread handle can be used for low-level + /// synchronization. See the module documentation for additional details. + #[unstable = "may change with specifics of new Send semantics"] + pub fn spawn(f: F) -> Thread where F: FnOnce(), F: Send + 'static { + Builder::new().spawn(f) + } + + /// Spawn a new *scoped* thread, returning a `JoinGuard` for it. /// /// The join guard can be used to explicitly join the child thread (via /// `join`), returning `Result`, or it will implicitly join the child - /// upon being dropped. To detach the child, allowing it to outlive the - /// current thread, use `detach`. See the module documentation for additional details. - pub fn spawn(f: F) -> JoinGuard where - T: Send, F: FnOnce() -> T, F: Send + /// upon being dropped. Because the child thread may refer to data on the + /// current thread's stack (hence the "scoped" name), it cannot be detached; + /// it *must* be joined before the relevant stack frame is popped. See the + /// module documentation for additional details. + #[unstable = "may change with specifics of new Send semantics"] + pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where + T: Send + 'a, F: FnOnce() -> T, F: Send + 'a { - Builder::new().spawn(f) + Builder::new().scoped(f) } /// Gets a handle to the thread that invokes it. + #[stable] pub fn current() -> Thread { thread_info::current_thread() } /// Cooperatively give up a timeslice to the OS scheduler. + #[unstable = "name may change"] pub fn yield_now() { unsafe { imp::yield_now() } } /// Determines whether the current thread is panicking. #[inline] + #[stable] pub fn panicking() -> bool { unwind::panicking() } @@ -341,6 +401,7 @@ impl Thread { // future, this will be implemented in a more efficient way, perhaps along the lines of // http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp // or futuxes, and in either case may allow spurious wakeups. + #[unstable = "recently introduced"] pub fn park() { let thread = Thread::current(); let mut guard = thread.inner.lock.lock().unwrap(); @@ -353,6 +414,7 @@ impl Thread { /// Atomically makes the handle's token available if it is not already. /// /// See the module doc for more detail. + #[unstable = "recently introduced"] pub fn unpark(&self) { let mut guard = self.inner.lock.lock().unwrap(); if !*guard { @@ -362,6 +424,7 @@ impl Thread { } /// Get the thread's name. + #[stable] pub fn name(&self) -> Option<&str> { self.inner.name.as_ref().map(|s| s.as_slice()) } @@ -375,6 +438,7 @@ impl thread_info::NewThread for Thread { /// Indicates the manner in which a thread exited. /// /// A thread that completes without panicking is considered to exit successfully. +#[stable] pub type Result = ::result::Result>; struct Packet(Arc>>>); @@ -382,21 +446,24 @@ struct Packet(Arc>>>); unsafe impl Send for Packet {} unsafe impl Sync for Packet {} -#[must_use] /// An RAII-style guard that will block until thread termination when dropped. /// /// The type `T` is the return type for the thread's main function. -pub struct JoinGuard { +#[must_use] +#[unstable = "may change with specifics of new Send semantics"] +pub struct JoinGuard<'a, T: 'a> { native: imp::rust_thread, thread: Thread, joined: bool, packet: Packet, } -unsafe impl Sync for JoinGuard {} +#[stable] +unsafe impl<'a, T: Send + 'a> Sync for JoinGuard<'a, T> {} -impl JoinGuard { +impl<'a, T: Send + 'a> JoinGuard<'a, T> { /// Extract a handle to the thread this guard will join on. + #[stable] pub fn thread(&self) -> &Thread { &self.thread } @@ -406,6 +473,7 @@ impl JoinGuard { /// /// If the child thread panics, `Err` is returned with the parameter given /// to `panic`. + #[stable] pub fn join(mut self) -> Result { assert!(!self.joined); unsafe { imp::join(self.native) }; @@ -414,8 +482,11 @@ impl JoinGuard { (*self.packet.0.get()).take().unwrap() } } +} +impl JoinGuard<'static, T> { /// Detaches the child thread, allowing it to outlive its parent. + #[experimental = "unsure whether this API imposes limitations elsewhere"] pub fn detach(mut self) { unsafe { imp::detach(self.native) }; self.joined = true; // avoid joining in the destructor @@ -424,7 +495,7 @@ impl JoinGuard { #[unsafe_destructor] #[stable] -impl Drop for JoinGuard { +impl<'a, T: Send + 'a> Drop for JoinGuard<'a, T> { fn drop(&mut self) { if !self.joined { unsafe { imp::join(self.native) }; From 570bda6657c46a41f032fd63154f1a675b36dd36 Mon Sep 17 00:00:00 2001 From: Alexander Light Date: Tue, 6 Jan 2015 12:15:41 -0500 Subject: [PATCH 15/49] update zsh rust completions --- src/etc/zsh/_rust | 162 ++++++++++++++++++++++++++-------------------- 1 file changed, 93 insertions(+), 69 deletions(-) diff --git a/src/etc/zsh/_rust b/src/etc/zsh/_rust index f4e8f6f7873c9..404f622f970c3 100644 --- a/src/etc/zsh/_rust +++ b/src/etc/zsh/_rust @@ -20,35 +20,37 @@ _rustc_crate_types=( _rustc_emit_types=( 'asm' - 'bc' - 'ir' + 'llvm-bc' + 'llvm-ir' 'obj' 'link' + 'dep-info' ) _rustc_pretty_types=( 'normal[un-annotated source]' 'expanded[crates expanded]' 'typed[crates expanded, with type annotations]' 'identified[fully parenthesized, AST nodes and blocks with IDs]' - 'flowgraph=[graphviz formatted flowgraph for node]:NODEID:' + 'flowgraph[graphviz formatted flowgraph for node]:NODEID:' ) _rustc_color_types=( 'auto[colorize, if output goes to a tty (default)]' 'always[always colorize output]' 'never[never colorize output]' ) +_rustc_info_types=( + 'crate-name[Output the crate name and exit]' + 'file-names[Output the file(s) that would be written if compilation continued and exited]' + 'sysroot[Output the sysroot and exit]' +) _rustc_opts_vals=( --crate-name='[Specify the name of the crate being built]' --crate-type='[Comma separated list of types of crates for the compiler to emit]:TYPES:_values -s "," "Crate types" "$_rustc_crate_types[@]"' --emit='[Comma separated list of types of output for the compiler to emit]:TYPES:_values -s "," "Emit Targets" "$_rustc_emit_types[@]"' - --debuginfo='[Emit DWARF debug info to the objects created]:LEVEL:_values "Debug Levels" "$_rustc_debuginfo_levels[@]"' - --dep-info='[Output dependency info to after compiling]::FILE:_files -/' - --sysroot='[Override the system root]:PATH:_files -/' --cfg='[Configure the compilation environment]:SPEC:' --out-dir='[Write output to compiler-chosen filename in

. Ignored if -o is specified. (default the current directory)]:DIR:_files -/' -o'[Write output to . Ignored if more than one --emit is specified.]:FILENAME:_files' - --opt-level='[Optimize with possible levels 0-3]:LEVEL:(0 1 2 3)' --pretty='[Pretty-print the input instead of compiling]::TYPE:_values "TYPES" "$_rustc_pretty_types[@]"' -L'[Add a directory to the library search path]:DIR:_files -/' --target='[Target triple cpu-manufacturer-kernel\[-os\] to compile]:TRIPLE:' @@ -56,27 +58,33 @@ _rustc_opts_vals=( {-v,--version}'[Print version info and exit]::VERBOSE:(verbose)' --explain='[Provide a detailed explanation of an error message]:OPT:' --extern'[Specify where an external rust library is located]:ARG:' + --print='[Comma separated list of compiler information to print on stdout]:TYPES:_values -s "," "Compiler Information" "$_rustc_info_types[@]"' ) _rustc_opts_switches=( - -g'[Equivalent to --debuginfo=2]' - {-h,--help}'[Display this message]' - --no-analysis'[Parse and expand the output, but run no analysis or produce output]' - --no-trans'[Run all passes except translation; no output]' - -O'[Equivalent to --opt-level=2]' - --parse-only'[Parse only; do not compile, assemble, or link]' - --print-crate-name'[Output the crate name and exit]' - --print-file-name'[Output the file(s) that would be written if compilation continued and exit]' + -g'[Equivalent to -C debuginfo=2]' + {-h,--help}'[Display the help message]' + {-V,--verbose}'[use verbose output]' + -O'[Equivalent to -C opt-level=2]' --test'[Build a test harness]' ) + + +_rustc_opts_link=( + 'static[Path to the library to link statically]:PATH:_files -/' + 'dylib[Path to the library to link dynamically]:PATH:_files -/' + 'framework[Path to the library to link as a framework]:PATH:_files -/' +) + _rustc_opts_codegen=( - 'ar=[Path to the archive utility to use when assembling archives.]:BIN:_path_files' - 'linker=[Path to the linker utility to use when linking libraries, executables, and objects.]:BIN:_path_files' - 'link-args=[A space-separated list of extra arguments to pass to the linker when the linker is invoked.]:ARGS:' - 'target-cpu=[Selects a target processor. If the value is "help", then a list of available CPUs is printed.]:CPU:' - 'target-feature=[A space-separated list of features to enable or disable for the target. A preceding "+" enables a feature while a preceding "-" disables it. Available features can be discovered through target-cpu=help.]:FEATURE:' - 'passes=[A space-separated list of extra LLVM passes to run. A value of "list" will cause rustc to print all known passes and exit. The passes specified are appended at the end of the normal pass manager.]:LIST:' - 'llvm-args=[A space-separated list of arguments to pass through to LLVM.]:ARGS:' + 'ar[Path to the archive utility to use when assembling archives.]:BIN:_path_files' + 'linker[Path to the linker utility to use when linking libraries, executables, and objects.]:BIN:_path_files' + 'link-args[A space-separated list of extra arguments to pass to the linker when the linker is invoked.]:ARGS:' + 'lto[Perform LLVM link-time optimizations]' + 'target-cpu[Selects a target processor. If the value is "help", then a list of available CPUs is printed.]:CPU:' + 'target-feature[A space-separated list of features to enable or disable for the target. A preceding "+" enables a feature while a preceding "-" disables it. Available features can be discovered through target-cpu=help.]:FEATURE:' + 'passes[A space-separated list of extra LLVM passes to run. A value of "list" will cause rustc to print all known passes and exit. The passes specified are appended at the end of the normal pass manager.]:LIST:' + 'llvm-args[A space-separated list of arguments to pass through to LLVM.]:ARGS:' 'save-temps[If specified, the compiler will save more files (.bc, .o, .no-opt.bc) generated throughout compilation in the output directory.]' 'rpath[If specified, then the rpath value for dynamic libraries will be set in either dynamic library or executable outputs.]' 'no-prepopulate-passes[Suppresses pre-population of the LLVM pass manager that is run over the module.]' @@ -86,55 +94,62 @@ _rustc_opts_codegen=( 'prefer-dynamic[Prefers dynamic linking to static linking.]' "no-integrated-as[Force usage of an external assembler rather than LLVM's integrated one.]" 'no-redzone[disable the use of the redzone]' - 'relocation-model=[The relocation model to use. (default: pic)]:MODEL:(pic static dynamic-no-pic)' - 'code-model=[choose the code model to use (llc -code-model for details)]:MODEL:' - 'metadata=[metadata to mangle symbol names with]:VAL:' - 'extra-filenames=[extra data to put in each output filename]:VAL:' - 'codegen-units=[divide crate into N units to optimize in parallel]:N:' + 'relocation-model[The relocation model to use. (default: pic)]:MODEL:(pic static dynamic-no-pic)' + 'code-model[choose the code model to use (llc -code-model for details)]:MODEL:' + 'metadata[metadata to mangle symbol names with]:VAL:' + 'extra-filenames[extra data to put in each output filename]:VAL:' + 'codegen-units[divide crate into N units to optimize in parallel]:N:' + 'remark[print remarks for these optimization passes (space separated, or "all")]:TYPE:' + 'debuginfo[debug info emission level, 0 = no debug info, 1 = line tables only, 2 = full debug info with variable and type information]:LEVEL:_values "Debug Levels" "$_rustc_debuginfo_levels[@]"' + 'opt-level[Optimize with possible levels 0-3]:LEVEL:(0 1 2 3)' 'help[Show all codegen options]' ) _rustc_opts_lint=( 'help[Show a list of all lints]' - 'experimental[detects use of #\[experimental\] items]' - 'heap-memory[use of any (Box type or @ type) heap memory]' - 'managed-heap-memory[use of managed (@ type) heap memory]' - 'missing-doc[detects missing documentation for public members]' - 'non-uppercase-statics[static constants should have uppercase identifiers]' - 'owned-heap-memory[use of owned (~ type) heap memory]' - 'unnecessary-qualification[detects unnecessarily qualified names]' - 'unsafe-block[usage of an `unsafe` block]' - 'unstable[detects use of #\[unstable\] items (incl. items with no stability attribute)]' - 'unused-result[unused result of an expression in a statement]' - 'variant-size-difference[detects enums with widely varying variant sizes]' - 'ctypes[proper use of libc types in foreign modules]' - 'dead-assignment[detect assignments that will never be read]' - 'dead-code[detect piece of code that will never be used]' - 'deprecated[detects use of #\[deprecated\] items]' - 'non-camel-case-types[types, variants and traits should have camel case names]' - 'non-snake-case[methods, functions, lifetime parameters and modules should have snake case names]' - 'path-statement[path statements with no effect]' - 'raw-pointer-deriving[uses of #\[deriving\] with raw pointers are rarely correct]' - 'type-limits[comparisons made useless by limits of the types involved]' - 'type-overflow[literal out of range for its type]' - 'unnecessary-allocation[detects unnecessary allocations that can be eliminated]' - 'unnecessary-parens[`if`, `match`, `while` and `return` do not need parentheses]' - 'unreachable-code[detects unreachable code]' - 'unrecognized-lint[unrecognized lint attribute]' - 'unsigned-negate[using an unary minus operator on unsigned type]' - 'unused-attribute[detects attributes that were not used by the compiler]' - 'unused-imports[imports that are never used]' - 'unused-must-use[unused result of a type flagged as #\[must_use\]]' - "unused-mut[detect mut variables which don't need to be mutable]" - 'unused-unsafe[unnecessary use of an `unsafe` block]' - 'unused-variable[detect variables which are not used in any way]' - 'visible-private-types[detect use of private types in exported type signatures]' - 'warnings[mass-change the level for lints which produce warnings]' - 'while-true[suggest using `loop { }` instead of `while true { }`]' - 'unknown-crate-type[unknown crate type found in #\[crate_type\] directive]' - 'unknown-features[unknown features found in crate-level #\[feature\] directives]' - 'bad-style[group of non_camel_case_types, non_snake_case, non_uppercase_statics]' - 'unused[group of unused_imports, unused_variable, dead_assignment, dead_code, unused_mut, unreachable_code]' + 'box-pointers[(default: allow) use of owned (Box type) heap memory]' + 'experimental[(default: allow) detects use of #\[experimental\] items]' + 'fat-ptr-transmutes[(default: allow) detects transmutes of fat pointers]' + 'missing-docs[(default: allow) detects missing documentation for public members]' + 'unsafe-blocks[(default: allow) usage of an "unsafe" block]' + 'unstable[(default: allow) detects use of #\[unstable\] items (incl. items with no stability attribute)]' + 'unused-extern-crates[(default: allow) extern crates that are never used]' + 'unused-import-braces[(default: allow) unnecessary braces around an imported item]' + 'unused-qualifications[(default: allow) detects unnecessarily qualified names]' + 'unused-results[(default: allow) unused result of an expression in a statement]' + 'unused-typecasts[(default: allow) detects unnecessary type casts that can be removed]' + 'variant-size-differences[(default: allow) detects enums with widely varying variant sizes]' + 'dead-code[(default: warn) detect unused, unexported items]' + 'deprecated[(default: warn) detects use of #\[deprecated\] items]' + 'improper-ctypes[(default: warn) proper use of libc types in foreign modules]' + 'missing-copy-implementations[(default: warn) detects potentially-forgotten implementations of "Copy"]' + 'non-camel-case-types[(default: warn) types, variants, traits and type parameters should have camel case names]' + 'non-shorthand-field-patterns[(default: warn) using "Struct { x: x }" instead of "Struct { x }"]' + 'non-snake-case[(default: warn) methods, functions, lifetime parameters and modules should have snake case names]' + 'non-upper-case-globals[(default: warn) static constants should have uppercase identifiers]' + 'overflowing-literals[(default: warn) literal out of range for its type]' + 'path-statements[(default: warn) path statements with no effect]' + 'raw-pointer-deriving[(default: warn) uses of #\[derive\] with raw pointers are rarely correct]' + 'unknown-lints[(default: warn) unrecognized lint attribute]' + 'unreachable-code[(default: warn) detects unreachable code paths]' + 'unsigned-negation[(default: warn) using an unary minus operator on unsigned type]' + 'unused-allocation[(default: warn) detects unnecessary allocations that can be eliminated]' + 'unused-assignments[(default: warn) detect assignments that will never be read]' + 'unused-attributes[(default: warn) detects attributes that were not used by the compiler]' + 'unused-comparisons[(default: warn) comparisons made useless by limits of the types involved]' + 'unused-imports[(default: warn) imports that are never used]' + 'unused-must-use[(default: warn) unused result of a type flagged as must_use]' + "unused-mut[(default: warn) detect mut variables which don't need to be mutable]" + 'unused-parens[(default: warn) "if", "match", "while" and "return" do not need parentheses]' + 'unused-unsafe[(default: warn) unnecessary use of an "unsafe" block]' + 'unused-variables[(default: warn) detect variables which are not used in any way]' + 'warnings[(default: warn) mass-change the level for lints which produce warnings]' + 'while-true[(default: warn) suggest using "loop { }" instead of "while true { }"]' + "exceeding-bitshifts[(default: deny) shift exceeds the type's number of bits]" + 'unknown-crate-types[(default: deny) unknown crate type found in #\[crate_type\] directive]' + 'unknown-features[(default: deny) unknown features found in crate-level #\[feature\] directives]' + 'bad-style[non-camel-case-types, non-snake-case, non-upper-case-globals]' + 'unused[unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unused-must-use, unused-unsafe, path-statements]' ) _rustc_opts_debug=( @@ -151,11 +166,9 @@ _rustc_opts_debug=( 'show-span[show spans for compiler debugging]' 'count-type-sizes[count the sizes of aggregate types]' 'meta-stats[gather metadata statistics]' - 'no-opt[do not optimize, even if -O is passed]' 'print-link-args[Print the arguments passed to the linker]' 'gc[Garbage collect shared data (experimental)]' 'print-llvm-passes[Prints the llvm optimization passes being run]' - 'lto[Perform LLVM link-time optimizations]' 'ast-json[Print the AST as JSON and halt]' 'ast-json-noexpand[Print the pre-expansion AST as JSON and halt]' 'ls[List the symbols defined by a library crate]' @@ -164,6 +177,12 @@ _rustc_opts_debug=( 'flowgraph-print-moves[Include move analysis data in --pretty flowgraph output]' 'flowgraph-print-assigns[Include assignment analysis data in --pretty flowgraph output]' 'flowgraph-print-all[Include all dataflow analysis data in --pretty flowgraph output]' + 'print-regiion-graph[Prints region inference graph. Use with RUST_REGION_GRAPH=help for more info]' + 'parse-only[Parse only; do not compile, assemble, or link]' + 'no-trans[Run all passes except translation; no output]' + 'no-analysis[Parse and expand the source, but run no analysis]' + 'unstable-options[Adds unstable command line options to rustc interface]' + 'print-enum-sizes[Print the size of enums and their variants]' ) _rustc_opts_fun_lint(){ @@ -179,13 +198,18 @@ _rustc_opts_fun_codegen(){ _values 'options' "$_rustc_opts_codegen[@]" } +_rustc_opts_fun_link(){ + _values 'options' "$_rustc_opts_link[@]" +} + _arguments -s : \ '(-W --warn)'{-W,--warn=}'[Set lint warnings]:lint options:_rustc_opts_fun_lint' \ '(-A --allow)'{-A,--allow=}'[Set lint allowed]:lint options:_rustc_opts_fun_lint' \ '(-D --deny)'{-D,--deny=}'[Set lint denied]:lint options:_rustc_opts_fun_lint' \ '(-F --forbid)'{-F,--forbid=}'[Set lint forbidden]:lint options:_rustc_opts_fun_lint' \ '*-Z[Set internal debugging options]:debug options:_rustc_opts_fun_debug' \ - '*-C[Set internal Codegen options]:codegen options:_rustc_opts_fun_codegen' \ + '(-C --codegen)'{-C,--codegen}'[Set internal Codegen options]:codegen options:_rustc_opts_fun_codegen' \ + '*-l[Link the generated crates to the specified native library NAME. the optional KIND can be one of, static, dylib, or framework. If omitted, dylib is assumed.]:ARG:_rustc_opts_fun_link' \ "$_rustc_opts_switches[@]" \ "$_rustc_opts_vals[@]" \ '::files:_files -g "*.rs"' From 7de9a73ab5891b190b3f49004fa75599a94c70ad Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Tue, 6 Jan 2015 09:20:40 -0800 Subject: [PATCH 16/49] Stabilize std::error This commit is a first past stabilization of `std::error`: * The module is stable. * The `FromError` trait and impls are stable * The `Error` trait itself is left unstable, pending current APIs and possible revisions during the alpha cycle. --- src/libstd/error.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/libstd/error.rs b/src/libstd/error.rs index 32e1922ae74fd..9963e4861b778 100644 --- a/src/libstd/error.rs +++ b/src/libstd/error.rs @@ -78,12 +78,15 @@ //! } //! ``` +#![stable] + use prelude::v1::*; use str::Utf8Error; use string::{FromUtf8Error, FromUtf16Error}; /// Base functionality for all errors in Rust. +#[unstable = "the exact API of this trait may change"] pub trait Error: Send { /// A short description of the error; usually a static string. fn description(&self) -> &str; @@ -96,18 +99,21 @@ pub trait Error: Send { } /// A trait for types that can be converted from a given error type `E`. +#[stable] pub trait FromError { /// Perform the conversion. fn from_error(err: E) -> Self; } // Any type is convertable from itself +#[stable] impl FromError for E { fn from_error(err: E) -> E { err } } +#[stable] impl Error for Utf8Error { fn description(&self) -> &str { match *self { @@ -119,11 +125,13 @@ impl Error for Utf8Error { fn detail(&self) -> Option { Some(self.to_string()) } } +#[stable] impl Error for FromUtf8Error { fn description(&self) -> &str { "invalid utf-8" } fn detail(&self) -> Option { Some(self.to_string()) } } +#[stable] impl Error for FromUtf16Error { fn description(&self) -> &str { "invalid utf-16" } } From 68cb17097ae92dd50ff076d4b34d955836c4977c Mon Sep 17 00:00:00 2001 From: klutzy Date: Wed, 7 Jan 2015 00:42:26 +0900 Subject: [PATCH 17/49] std: prevent `CreateProcess()` race on Windows Believe or not, `CreateProcess()` is racy if several threads create child processes: [0], [1], [2]. This caused some tests show crash dialogs during `make check-stage#-rpass`. More explanation: On Windows, `SetErrorMode()` controls display of error dialogs: it accepts new error mode and returns old error mode. The error mode is process-global and automatically inherited to child process when created. MSYS2 bash shell internally sets it to not show error dialogs, therefore `make check-stage#-rpass` should not show them either. However, [1] says that `CreateProcess()` internally invokes `SetErrorMode()` twice: at first it sets mode `0x8001` and saves original mode, and at second it restores original mode. So if two threads simultaneously call `CreateProcess()`, the first thread sets error mode to `0x8001` then the second thread recognizes that current error mode is `0x8001`. Therefore, The second thread will create process with wrong error mode. This really occurs inside `compiletest`: it creates several processes on each thread, so some `run-pass` tests are invoked with wrong error mode therefore show crash dialog. This commit adds `StaticMutex` for `CreateProcess()` call. This seems to fix the "dialog annoyance" issue. [0]: http://support.microsoft.com/kb/315939 [1]: https://code.google.com/p/nativeclient/issues/detail?id=2968 [2]: https://ghc.haskell.org/trac/ghc/ticket/2650 --- src/libstd/sys/windows/process.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 7b667416b1714..8e1f169b5cdcc 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -25,6 +25,8 @@ use path::BytesContainer; use ptr; use str; use sys::fs::FileDesc; +use sync::{StaticMutex, MUTEX_INIT}; + use sys::fs; use sys::{self, retry, c, wouldblock, set_nonblocking, ms_to_timeval, timer}; use sys_common::helper_thread::Helper; @@ -32,6 +34,10 @@ use sys_common::{AsInner, mkerr_libc, timeout}; pub use sys_common::ProcessConfig; +// `CreateProcess` is racy! +// http://support.microsoft.com/kb/315939 +static CREATE_PROCESS_LOCK: StaticMutex = MUTEX_INIT; + /// A value representing a child process. /// /// The lifetime of this value is linked to the lifetime of the actual @@ -224,6 +230,7 @@ impl Process { with_dirp(cfg.cwd(), |dirp| { let mut cmd_str: Vec = cmd_str.utf16_units().collect(); cmd_str.push(0); + let _lock = CREATE_PROCESS_LOCK.lock().unwrap(); let created = CreateProcessW(ptr::null(), cmd_str.as_mut_ptr(), ptr::null_mut(), From 134eb0e26f6c2d89b852995295d364614d6b7299 Mon Sep 17 00:00:00 2001 From: Michael Neumann Date: Tue, 6 Jan 2015 10:53:32 +0100 Subject: [PATCH 18/49] Tuning pthread_key_t type Both FreeBSD and DragonFly define pthread_key_t as int, while Linux defines it as uint. As pthread_key_t is used as an opaque type and storage size of both int and uint are the same, this is rather a cosmetic change. iOS uses ulong (as OS X) so difference is critical on 64bit platforms. --- src/libstd/sys/unix/thread_local.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/libstd/sys/unix/thread_local.rs b/src/libstd/sys/unix/thread_local.rs index e507377a8fcdd..ea1e9c261fecf 100644 --- a/src/libstd/sys/unix/thread_local.rs +++ b/src/libstd/sys/unix/thread_local.rs @@ -37,10 +37,18 @@ pub unsafe fn destroy(key: Key) { debug_assert_eq!(r, 0); } -#[cfg(target_os = "macos")] +#[cfg(any(target_os = "macos", + target_os = "ios"))] type pthread_key_t = ::libc::c_ulong; -#[cfg(not(target_os = "macos"))] +#[cfg(any(target_os = "freebsd", + target_os = "dragonfly"))] +type pthread_key_t = ::libc::c_int; + +#[cfg(not(any(target_os = "macos", + target_os = "ios", + target_os = "freebsd", + target_os = "dragonfly")))] type pthread_key_t = ::libc::c_uint; extern { From 2486d93e5b8a3dd62fa6d257d4086e19c0e0edd6 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 6 Jan 2015 05:03:42 -0500 Subject: [PATCH 19/49] Fix ICE that @steveklabnik encountered in rust-ice. The problems turned out to be that were being very loose with bound regions in trans (we were basically just ignoring and flattening binders). Since binders are significant to subtyping and hence to trait selection, this can cause a lot of problems. So this patch makes us treat them more strictly -- for example, we propagate binders, and avoid skipping past the `Binder` by writing `foo.0`. Fixes #20644. --- src/librustc/middle/cfg/construct.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 7 +- src/librustc/middle/liveness.rs | 22 +++-- src/librustc/middle/mem_categorization.rs | 31 +++++-- src/librustc/middle/ty.rs | 103 ++++++++++++---------- src/librustc/middle/ty_fold.rs | 3 + src/librustc_trans/trans/base.rs | 62 ++++++++----- src/librustc_trans/trans/callee.rs | 46 +++++----- src/librustc_trans/trans/closure.rs | 8 +- src/librustc_trans/trans/common.rs | 55 ++++++++++++ src/librustc_trans/trans/controlflow.rs | 7 +- src/librustc_trans/trans/debuginfo.rs | 51 +++++++---- src/librustc_trans/trans/expr.rs | 18 +++- src/librustc_trans/trans/foreign.rs | 32 ++++--- src/librustc_trans/trans/glue.rs | 8 +- src/librustc_trans/trans/intrinsic.rs | 8 +- src/librustc_trans/trans/meth.rs | 32 ++++--- src/librustc_trans/trans/type_of.rs | 25 +++--- src/librustc_typeck/check/_match.rs | 5 +- src/librustc_typeck/check/mod.rs | 10 ++- src/librustc_typeck/check/regionck.rs | 4 +- src/librustc_typeck/check/wf.rs | 8 +- src/test/run-pass/issue-20644.rs | 35 ++++++++ 23 files changed, 399 insertions(+), 183 deletions(-) create mode 100644 src/test/run-pass/issue-20644.rs diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 3c672d0fdb6fa..dedd321191595 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -514,7 +514,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let func_or_rcvr_exit = self.expr(func_or_rcvr, pred); let ret = self.straightline(call_expr, func_or_rcvr_exit, args); - if return_ty == ty::FnDiverging { + if return_ty.diverges() { self.add_node(ast::DUMMY_NODE_ID, &[]) } else { ret diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index df2a4e4c2532a..4d6e494cc82ea 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -864,7 +864,12 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { None => {} Some(method_ty) => { let cmt = return_if_err!(self.mc.cat_expr_autoderefd(expr, i)); - let self_ty = ty::ty_fn_args(method_ty)[0]; + + // the method call infrastructure should have + // replaced all late-bound regions with variables: + let self_ty = ty::ty_fn_sig(method_ty).input(0); + let self_ty = ty::assert_no_late_bound_regions(self.tcx(), &self_ty); + let (m, r) = match self_ty.sty { ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => self.tcx().sess.span_bug(expr.span, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 77875139be3a3..fe067ba8b00a1 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -112,6 +112,7 @@ use self::VarKind::*; use middle::def::*; use middle::mem_categorization::Typer; use middle::pat_util; +use middle::region::CodeExtent; use middle::ty; use middle::ty::UnboxedClosureTyper; use lint; @@ -1149,8 +1150,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { ast::ExprCall(ref f, ref args) => { let diverges = !self.ir.tcx.is_method_call(expr.id) && { - let t_ret = ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f)); - t_ret == ty::FnDiverging + ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f)).diverges() }; let succ = if diverges { self.s.exit_ln @@ -1164,7 +1164,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { ast::ExprMethodCall(_, _, ref args) => { let method_call = ty::MethodCall::expr(expr.id); let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty; - let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging; + let diverges = ty::ty_fn_ret(method_ty).diverges(); let succ = if diverges { self.s.exit_ln } else { @@ -1514,11 +1514,11 @@ fn check_fn(_v: &Liveness, } impl<'a, 'tcx> Liveness<'a, 'tcx> { - fn fn_ret(&self, id: NodeId) -> ty::FnOutput<'tcx> { + fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> { let fn_ty = ty::node_id_to_type(self.ir.tcx, id); match fn_ty.sty { ty::ty_unboxed_closure(closure_def_id, _, substs) => - self.ir.tcx.unboxed_closure_type(closure_def_id, substs).sig.0.output, + self.ir.tcx.unboxed_closure_type(closure_def_id, substs).sig.output(), _ => ty::ty_fn_ret(fn_ty), } @@ -1529,8 +1529,16 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { sp: Span, _fk: FnKind, entry_ln: LiveNode, - body: &ast::Block) { - match self.fn_ret(id) { + body: &ast::Block) + { + // within the fn body, late-bound regions are liberated: + let fn_ret = + ty::liberate_late_bound_regions( + self.ir.tcx, + CodeExtent::from_node_id(body.id), + &self.fn_ret(id)); + + match fn_ret { ty::FnConverging(t_ret) if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => { diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2b8c9b532e593..91c2681ef613a 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -492,9 +492,10 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { let method_call = ty::MethodCall::expr(expr.id()); match self.typer.node_method_ty(method_call) { Some(method_ty) => { - // If this is an index implemented by a method call, then it will - // include an implicit deref of the result. - let ret_ty = ty::ty_fn_ret(method_ty).unwrap(); + // If this is an index implemented by a + // method call, then it will include an + // implicit deref of the result. + let ret_ty = self.overloaded_method_return_ty(method_ty); self.cat_deref(expr, self.cat_rvalue_node(expr.id(), expr.span(), @@ -865,7 +866,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { let base_cmt = match method_ty { Some(method_ty) => { - let ref_ty = ty::ty_fn_ret(method_ty).unwrap(); + let ref_ty = + ty::assert_no_late_bound_regions( + self.tcx(), &ty::ty_fn_ret(method_ty)).unwrap(); self.cat_rvalue_node(node.id(), node.span(), ref_ty) } None => base_cmt @@ -945,9 +948,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { let element_ty = match method_ty { Some(method_ty) => { - let ref_ty = ty::ty_fn_ret(method_ty).unwrap(); + let ref_ty = self.overloaded_method_return_ty(method_ty); base_cmt = self.cat_rvalue_node(elt.id(), elt.span(), ref_ty); - ty::ty_fn_args(method_ty)[0] + + // FIXME(#20649) -- why are we using the `self_ty` as the element type...? + let self_ty = ty::ty_fn_sig(method_ty).input(0); + ty::assert_no_late_bound_regions(self.tcx(), &self_ty) } None => { match ty::array_element_ty(self.tcx(), base_cmt.ty) { @@ -1269,6 +1275,19 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { Ok(()) } + + fn overloaded_method_return_ty(&self, + method_ty: Ty<'tcx>) + -> Ty<'tcx> + { + // When we process an overloaded `*` or `[]` etc, we often + // need to extract the return type of the method. These method + // types are generated by method resolution and always have + // all late-bound regions fully instantiated, so we just want + // to skip past the binder. + ty::assert_no_late_bound_regions(self.tcx(), &ty::ty_fn_ret(method_ty)) + .unwrap() // overloaded ops do not diverge, either + } } #[derive(Copy)] diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c359233eca173..192f86bfa624a 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -1054,6 +1054,10 @@ pub enum FnOutput<'tcx> { } impl<'tcx> FnOutput<'tcx> { + pub fn diverges(&self) -> bool { + *self == FnDiverging + } + pub fn unwrap(self) -> Ty<'tcx> { match self { ty::FnConverging(t) => t, @@ -1062,6 +1066,14 @@ impl<'tcx> FnOutput<'tcx> { } } +pub type PolyFnOutput<'tcx> = Binder>; + +impl<'tcx> PolyFnOutput<'tcx> { + pub fn diverges(&self) -> bool { + self.0.diverges() + } +} + /// Signature of a function type, which I have arbitrarily /// decided to use to refer to the input/output types. /// @@ -1077,6 +1089,21 @@ pub struct FnSig<'tcx> { pub type PolyFnSig<'tcx> = Binder>; +impl<'tcx> PolyFnSig<'tcx> { + pub fn inputs(&self) -> ty::Binder>> { + ty::Binder(self.0.inputs.clone()) + } + pub fn input(&self, index: uint) -> ty::Binder> { + ty::Binder(self.0.inputs[index]) + } + pub fn output(&self) -> ty::Binder> { + ty::Binder(self.0.output.clone()) + } + pub fn variadic(&self) -> bool { + self.0.variadic + } +} + #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub struct ParamTy { pub space: subst::ParamSpace, @@ -4145,8 +4172,8 @@ pub fn ty_fn_abi(fty: Ty) -> abi::Abi { } // Type accessors for substructures of types -pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> &'tcx [Ty<'tcx>] { - ty_fn_sig(fty).0.inputs.as_slice() +pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> ty::Binder>> { + ty_fn_sig(fty).inputs() } pub fn ty_closure_store(fty: Ty) -> TraitStore { @@ -4162,9 +4189,9 @@ pub fn ty_closure_store(fty: Ty) -> TraitStore { } } -pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> FnOutput<'tcx> { +pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> Binder> { match fty.sty { - ty_bare_fn(_, ref f) => f.sig.0.output, + ty_bare_fn(_, ref f) => f.sig.output(), ref s => { panic!("ty_fn_ret() called on non-fn type: {}", s) } @@ -4319,9 +4346,12 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, let method_call = MethodCall::autoderef(expr_id, i); match method_type(method_call) { Some(method_ty) => { - if let ty::FnConverging(result_type) = ty_fn_ret(method_ty) { - adjusted_ty = result_type; - } + // overloaded deref operators have all late-bound + // regions fully instantiated and coverge + let fn_ret = + ty::assert_no_late_bound_regions(cx, + &ty_fn_ret(method_ty)); + adjusted_ty = fn_ret.unwrap(); } None => {} } @@ -5143,7 +5173,9 @@ impl<'tcx> VariantInfo<'tcx> { match ast_variant.node.kind { ast::TupleVariantKind(ref args) => { let arg_tys = if args.len() > 0 { - ty_fn_args(ctor_ty).iter().map(|a| *a).collect() + // the regions in the argument types come from the + // enum def'n, and hence will all be early bound + ty::assert_no_late_bound_regions(cx, &ty_fn_args(ctor_ty)) } else { Vec::new() }; @@ -5159,7 +5191,6 @@ impl<'tcx> VariantInfo<'tcx> { }; }, ast::StructVariantKind(ref struct_def) => { - let fields: &[StructField] = struct_def.fields[]; assert!(fields.len() > 0); @@ -5791,40 +5822,6 @@ pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool return tbl[tycat(cx, ty) as uint ][opcat(op) as uint]; } -/// Returns an equivalent type with all the typedefs and self regions removed. -pub fn normalize_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { - let u = TypeNormalizer(cx).fold_ty(ty); - return u; - - struct TypeNormalizer<'a, 'tcx: 'a>(&'a ctxt<'tcx>); - - impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> { - fn tcx(&self) -> &ctxt<'tcx> { let TypeNormalizer(c) = *self; c } - - fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { - match self.tcx().normalized_cache.borrow().get(&ty).cloned() { - None => {} - Some(u) => return u - } - - let t_norm = ty_fold::super_fold_ty(self, ty); - self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm); - return t_norm; - } - - fn fold_region(&mut self, _: ty::Region) -> ty::Region { - ty::ReStatic - } - - fn fold_substs(&mut self, - substs: &subst::Substs<'tcx>) - -> subst::Substs<'tcx> { - subst::Substs { regions: subst::ErasedRegions, - types: substs.types.fold_with(self) } - } - } -} - // Returns the repeat count for a repeating vector expression. pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { match const_eval::eval_const_expr_partial(tcx, count_expr) { @@ -6204,7 +6201,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - mt.mutbl.hash(state); }; let fn_sig = |&: state: &mut sip::SipState, sig: &Binder>| { - let sig = anonymize_late_bound_regions(tcx, sig); + let sig = anonymize_late_bound_regions(tcx, sig).0; for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { helper(tcx, output, svh, state); @@ -6265,7 +6262,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - did(state, data.principal_def_id()); hash!(data.bounds); - let principal = anonymize_late_bound_regions(tcx, &data.principal); + let principal = anonymize_late_bound_regions(tcx, &data.principal).0; for subty in principal.substs.types.iter() { helper(tcx, *subty, svh, state); } @@ -6696,6 +6693,16 @@ pub fn binds_late_bound_regions<'tcx, T>( count_late_bound_regions(tcx, value) > 0 } +pub fn assert_no_late_bound_regions<'tcx, T>( + tcx: &ty::ctxt<'tcx>, + value: &Binder) + -> T + where T : TypeFoldable<'tcx> + Repr<'tcx> + Clone +{ + assert!(!binds_late_bound_regions(tcx, value)); + value.0.clone() +} + /// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also /// method lookup and a few other places where precise region relationships are not required. pub fn erase_late_bound_regions<'tcx, T>( @@ -6718,14 +6725,14 @@ pub fn erase_late_bound_regions<'tcx, T>( pub fn anonymize_late_bound_regions<'tcx, T>( tcx: &ctxt<'tcx>, sig: &Binder) - -> T + -> Binder where T : TypeFoldable<'tcx> + Repr<'tcx>, { let mut counter = 0; - replace_late_bound_regions(tcx, sig, |_, db| { + ty::Binder(replace_late_bound_regions(tcx, sig, |_, db| { counter += 1; ReLateBound(db, BrAnon(counter)) - }).0 + }).0) } /// Replaces the late-bound-regions in `value` that are bound by `value`. diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 1bc0d70945899..564858a462ae6 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -868,6 +868,9 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionEraser<'a, 'tcx> { fn tcx(&self) -> &ty::ctxt<'tcx> { self.tcx } fn fold_region(&mut self, r: ty::Region) -> ty::Region { + // because whether or not a region is bound affects subtyping, + // we can't erase the bound/free distinction, but we can + // replace all free regions with 'static match r { ty::ReLateBound(..) | ty::ReEarlyBound(..) => r, _ => ty::ReStatic diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index edcfaae0f802d..19c9b74743464 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -283,35 +283,40 @@ pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>, name: &str) -> ValueRef { let fn_ty = monomorphize::normalize_associated_type(ccx.tcx(), &fn_ty); - let (inputs, output, abi, env) = match fn_ty.sty { + let function_type; // placeholder so that the memory ownership works out ok + + let (sig, abi, env) = match fn_ty.sty { ty::ty_bare_fn(_, ref f) => { - (f.sig.0.inputs.clone(), f.sig.0.output, f.abi, None) + (&f.sig, f.abi, None) } ty::ty_unboxed_closure(closure_did, _, substs) => { let typer = common::NormalizingUnboxedClosureTyper::new(ccx.tcx()); - let function_type = typer.unboxed_closure_type(closure_did, substs); + function_type = typer.unboxed_closure_type(closure_did, substs); let self_type = self_type_for_unboxed_closure(ccx, closure_did, fn_ty); let llenvironment_type = type_of_explicit_arg(ccx, self_type); debug!("decl_rust_fn: function_type={} self_type={}", function_type.repr(ccx.tcx()), self_type.repr(ccx.tcx())); - (function_type.sig.0.inputs, - function_type.sig.0.output, - RustCall, - Some(llenvironment_type)) + (&function_type.sig, RustCall, Some(llenvironment_type)) } _ => panic!("expected closure or fn") }; - let llfty = type_of_rust_fn(ccx, env, inputs[], output, abi); - debug!("decl_rust_fn(input count={},type={})", - inputs.len(), + let sig = ty::erase_late_bound_regions(ccx.tcx(), sig); + let sig = ty::Binder(sig); + + let llfty = type_of_rust_fn(ccx, env, &sig, abi); + + debug!("decl_rust_fn(sig={}, type={})", + sig.repr(ccx.tcx()), ccx.tn().type_to_string(llfty)); - let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, output); + let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, sig.0.output /* (1) */); let attrs = get_fn_llvm_attributes(ccx, fn_ty); attrs.apply_llfn(llfn); + // (1) it's ok to directly access sig.0.output because we erased all late-bound-regions above + llfn } @@ -1938,7 +1943,7 @@ pub fn trans_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx())); let _icx = push_ctxt("trans_fn"); let fn_ty = ty::node_id_to_type(ccx.tcx(), id); - let output_type = ty::ty_fn_ret(fn_ty); + let output_type = ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fn_ty)); let abi = ty::ty_fn_abi(fn_ty); trans_closure(ccx, decl, @@ -1981,7 +1986,9 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let tcx = ccx.tcx(); let result_ty = match ctor_ty.sty { - ty::ty_bare_fn(_, ref bft) => bft.sig.0.output.unwrap(), + ty::ty_bare_fn(_, ref bft) => { + ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap() + } _ => ccx.sess().bug( format!("trans_enum_variant_constructor: \ unexpected ctor return type {}", @@ -2053,7 +2060,9 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx let ctor_ty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, &ctor_ty); let result_ty = match ctor_ty.sty { - ty::ty_bare_fn(_, ref bft) => bft.sig.0.output, + ty::ty_bare_fn(_, ref bft) => { + ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output()) + } _ => ccx.sess().bug( format!("trans_enum_variant_or_tuple_like_struct: \ unexpected ctor return type {}", @@ -2067,7 +2076,9 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx assert!(!fcx.needs_ret_allocas); - let arg_tys = ty::ty_fn_args(ctor_ty); + let arg_tys = + ty::erase_late_bound_regions( + ccx.tcx(), &ty::ty_fn_args(ctor_ty)); let arg_datums = create_datums_for_fn_args(&fcx, arg_tys[]); @@ -2426,25 +2437,28 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>) - -> llvm::AttrBuilder { + -> llvm::AttrBuilder +{ use middle::ty::{BrAnon, ReLateBound}; + let function_type; let (fn_sig, abi, has_env) = match fn_ty.sty { - ty::ty_bare_fn(_, ref f) => (f.sig.clone(), f.abi, false), + ty::ty_bare_fn(_, ref f) => (&f.sig, f.abi, false), ty::ty_unboxed_closure(closure_did, _, substs) => { let typer = common::NormalizingUnboxedClosureTyper::new(ccx.tcx()); - let function_type = typer.unboxed_closure_type(closure_did, substs); - (function_type.sig, RustCall, true) + function_type = typer.unboxed_closure_type(closure_did, substs); + (&function_type.sig, RustCall, true) } _ => ccx.sess().bug("expected closure or function.") }; + let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); // Since index 0 is the return value of the llvm func, we start // at either 1 or 2 depending on whether there's an env slot or not let mut first_arg_offset = if has_env { 2 } else { 1 }; let mut attrs = llvm::AttrBuilder::new(); - let ret_ty = fn_sig.0.output; + let ret_ty = fn_sig.output; // These have an odd calling convention, so we need to manually // unpack the input ty's @@ -2452,15 +2466,15 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty< ty::ty_unboxed_closure(_, _, _) => { assert!(abi == RustCall); - match fn_sig.0.inputs[0].sty { + match fn_sig.inputs[0].sty { ty::ty_tup(ref inputs) => inputs.clone(), _ => ccx.sess().bug("expected tuple'd inputs") } }, ty::ty_bare_fn(..) if abi == RustCall => { - let mut inputs = vec![fn_sig.0.inputs[0]]; + let mut inputs = vec![fn_sig.inputs[0]]; - match fn_sig.0.inputs[1].sty { + match fn_sig.inputs[1].sty { ty::ty_tup(ref t_in) => { inputs.push_all(t_in[]); inputs @@ -2468,7 +2482,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty< _ => ccx.sess().bug("expected tuple'd inputs") } } - _ => fn_sig.0.inputs.clone() + _ => fn_sig.inputs.clone() }; if let ty::FnConverging(ret_ty) = ret_ty { diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 65e6d7e1924b6..a5ed42c99ebce 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -265,7 +265,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( let _icx = push_ctxt("trans_fn_pointer_shim"); let tcx = ccx.tcx(); - let bare_fn_ty = ty::normalize_ty(tcx, bare_fn_ty); + let bare_fn_ty = normalize_ty(tcx, bare_fn_ty); match ccx.fn_pointer_shims().borrow().get(&bare_fn_ty) { Some(&llval) => { return llval; } None => { } @@ -279,16 +279,13 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( // Construct the "tuply" version of `bare_fn_ty`. It takes two arguments: `self`, // which is the fn pointer, and `args`, which is the arguments tuple. - let (opt_def_id, input_tys, output_ty) = + let (opt_def_id, sig) = match bare_fn_ty.sty { ty::ty_bare_fn(opt_def_id, &ty::BareFnTy { unsafety: ast::Unsafety::Normal, - abi: synabi::Rust, - sig: ty::Binder(ty::FnSig { inputs: ref input_tys, - output: output_ty, - variadic: false })}) => - { - (opt_def_id, input_tys, output_ty) + abi: synabi::Rust, + ref sig }) => { + (opt_def_id, sig) } _ => { @@ -296,7 +293,8 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( bare_fn_ty.repr(tcx))[]); } }; - let tuple_input_ty = ty::mk_tup(tcx, input_tys.to_vec()); + let sig = ty::erase_late_bound_regions(tcx, sig); + let tuple_input_ty = ty::mk_tup(tcx, sig.inputs.to_vec()); let tuple_fn_ty = ty::mk_bare_fn(tcx, opt_def_id, tcx.mk_bare_fn(ty::BareFnTy { @@ -305,7 +303,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( sig: ty::Binder(ty::FnSig { inputs: vec![bare_fn_ty_ref, tuple_input_ty], - output: output_ty, + output: sig.output, variadic: false })})); debug!("tuple_fn_ty: {}", tuple_fn_ty.repr(tcx)); @@ -326,11 +324,11 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( llfn, ast::DUMMY_NODE_ID, false, - output_ty, + sig.output, &empty_substs, None, &block_arena); - let mut bcx = init_function(&fcx, false, output_ty); + let mut bcx = init_function(&fcx, false, sig.output); // the first argument (`self`) will be ptr to the the fn pointer let llfnpointer = @@ -338,14 +336,14 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( // the remaining arguments will be the untupled values let llargs: Vec<_> = - input_tys.iter() + sig.inputs.iter() .enumerate() .map(|(i, _)| get_param(fcx.llfn, fcx.arg_pos(i+1) as u32)) .collect(); assert!(!fcx.needs_ret_allocas); let dest = fcx.llretslotptr.get().map(|_| - expr::SaveIn(fcx.get_ret_slot(bcx, output_ty, "ret_slot")) + expr::SaveIn(fcx.get_ret_slot(bcx, sig.output, "ret_slot")) ); bcx = trans_call_inner(bcx, @@ -355,7 +353,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( ArgVals(llargs[]), dest).bcx; - finish_fn(&fcx, bcx, output_ty); + finish_fn(&fcx, bcx, sig.output); ccx.fn_pointer_shims().borrow_mut().insert(bare_fn_ty, llfn); @@ -668,7 +666,10 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let mut bcx = callee.bcx; let (abi, ret_ty) = match callee_ty.sty { - ty::ty_bare_fn(_, ref f) => (f.abi, f.sig.0.output), + ty::ty_bare_fn(_, ref f) => { + let output = ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()); + (f.abi, output) + } _ => panic!("expected bare rust fn or closure in trans_call_inner") }; @@ -865,13 +866,18 @@ fn trans_args_under_call_abi<'blk, 'tcx>( llargs: &mut Vec, arg_cleanup_scope: cleanup::ScopeId, ignore_self: bool) - -> Block<'blk, 'tcx> { + -> Block<'blk, 'tcx> +{ + let args = + ty::erase_late_bound_regions( + bcx.tcx(), &ty::ty_fn_args(fn_ty)); + // Translate the `self` argument first. if !ignore_self { let arg_datum = unpack_datum!(bcx, expr::trans(bcx, &*arg_exprs[0])); llargs.push(unpack_result!(bcx, { trans_arg_datum(bcx, - ty::ty_fn_args(fn_ty)[0], + args[0], arg_datum, arg_cleanup_scope, DontAutorefArg) @@ -926,7 +932,7 @@ fn trans_overloaded_call_args<'blk, 'tcx>( ignore_self: bool) -> Block<'blk, 'tcx> { // Translate the `self` argument first. - let arg_tys = ty::ty_fn_args(fn_ty); + let arg_tys = ty::erase_late_bound_regions(bcx.tcx(), &ty::ty_fn_args(fn_ty)); if !ignore_self { let arg_datum = unpack_datum!(bcx, expr::trans(bcx, arg_exprs[0])); llargs.push(unpack_result!(bcx, { @@ -974,7 +980,7 @@ pub fn trans_args<'a, 'blk, 'tcx>(cx: Block<'blk, 'tcx>, debug!("trans_args(abi={})", abi); let _icx = push_ctxt("trans_args"); - let arg_tys = ty::ty_fn_args(fn_ty); + let arg_tys = ty::erase_late_bound_regions(cx.tcx(), &ty::ty_fn_args(fn_ty)); let variadic = ty::fn_is_variadic(fn_ty); let mut bcx = cx; diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index 6f2def16e7674..ad5159f0e990b 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -442,7 +442,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.fcx.param_substs, id, &[], - ty::ty_fn_ret(fty), + ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fty)), ty::ty_fn_abi(fty), ClosureEnv::new(freevars[], BoxedClosure(cdata_ty, store))); @@ -466,7 +466,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext // Normalize type so differences in regions and typedefs don't cause // duplicate declarations - let function_type = ty::normalize_ty(ccx.tcx(), function_type); + let function_type = normalize_ty(ccx.tcx(), function_type); let params = match function_type.sty { ty::ty_unboxed_closure(_, _, ref substs) => substs.types.clone(), _ => unreachable!() @@ -533,6 +533,8 @@ pub fn trans_unboxed_closure<'blk, 'tcx>( ty::with_freevars(bcx.tcx(), id, |fv| fv.iter().map(|&fv| fv).collect()); let freevar_mode = bcx.tcx().capture_mode(id); + let sig = ty::erase_late_bound_regions(bcx.tcx(), &function_type.sig); + trans_closure(bcx.ccx(), decl, body, @@ -540,7 +542,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>( bcx.fcx.param_substs, id, &[], - function_type.sig.0.output, + sig.output, function_type.abi, ClosureEnv::new(freevars[], UnboxedClosure(freevar_mode))); diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 094f98e988aad..3a9bd77c5161e 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -58,6 +58,61 @@ use util::nodemap::FnvHashSet; pub use trans::context::CrateContext; +/// Returns an equivalent type with all the typedefs and self regions removed. +pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { + let u = TypeNormalizer(cx).fold_ty(ty); + debug!("normalize_ty({}) = {}", + ty.repr(cx), u.repr(cx)); + return u; + + struct TypeNormalizer<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>); + + impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> { + fn tcx(&self) -> &ty::ctxt<'tcx> { self.0 } + + fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { + match self.tcx().normalized_cache.borrow().get(&ty).cloned() { + None => {} + Some(u) => return u + } + + let t_norm = ty_fold::super_fold_ty(self, ty); + self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm); + return t_norm; + } + + fn fold_binder(&mut self, t: &ty::Binder) -> ty::Binder + where T : TypeFoldable<'tcx> + Repr<'tcx> + { + // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`. + let u = ty::anonymize_late_bound_regions(self.tcx(), t); + ty_fold::super_fold_binder(self, &u) + } + + fn fold_region(&mut self, r: ty::Region) -> ty::Region { + // because late-bound regions affect subtyping, we can't + // erase the bound/free distinction, but we can replace + // all free regions with 'static. + // + // Note that we *CAN* replace early-bound regions -- the + // type system never "sees" those, they get substituted + // away. In trans, they will always be erased to 'static + // whenever a substitution occurs. + match r { + ty::ReLateBound(..) => r, + _ => ty::ReStatic + } + } + + fn fold_substs(&mut self, + substs: &subst::Substs<'tcx>) + -> subst::Substs<'tcx> { + subst::Substs { regions: subst::ErasedRegions, + types: substs.types.fold_with(self) } + } + } +} + // Is the type's representation size known at compile time? pub fn type_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::type_contents(cx, ty).is_sized(cx) diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index 768de89d5935d..afb43c38762a3 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -265,7 +265,8 @@ pub fn trans_for<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, pat: &ast::Pat, head: &ast::Expr, body: &ast::Block) - -> Block<'blk, 'tcx> { + -> Block<'blk, 'tcx> +{ let _icx = push_ctxt("trans_for"); // bcx @@ -306,7 +307,9 @@ pub fn trans_for<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, .borrow())[method_call] .ty; let method_type = monomorphize_type(loopback_bcx_in, method_type); - let method_result_type = ty::ty_fn_ret(method_type).unwrap(); + let method_result_type = + ty::assert_no_late_bound_regions( // LB regions are instantiated in invoked methods + loopback_bcx_in.tcx(), &ty::ty_fn_ret(method_type)).unwrap(); let option_cleanup_scope = body_bcx_in.fcx.push_custom_cleanup_scope(); let option_cleanup_scope_id = cleanup::CustomScope(option_cleanup_scope); diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 3f0f7fd9bd303..59a918d6509ba 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -425,10 +425,14 @@ impl<'tcx> TypeMap<'tcx> { ty::ty_trait(ref trait_data) => { unique_type_id.push_str("trait "); + let principal = + ty::erase_late_bound_regions(cx.tcx(), + &trait_data.principal); + from_def_id_and_substs(self, cx, - trait_data.principal_def_id(), - trait_data.principal.0.substs, + principal.def_id, + principal.substs, &mut unique_type_id); }, ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { @@ -440,7 +444,9 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push_str(" fn("); - for ¶meter_type in sig.0.inputs.iter() { + let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + + for ¶meter_type in sig.inputs.iter() { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -449,12 +455,12 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push(','); } - if sig.0.variadic { + if sig.variadic { unique_type_id.push_str("..."); } unique_type_id.push_str(")->"); - match sig.0.output { + match sig.output { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); @@ -568,7 +574,9 @@ impl<'tcx> TypeMap<'tcx> { } }; - for ¶meter_type in sig.0.inputs.iter() { + let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + + for ¶meter_type in sig.inputs.iter() { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -577,13 +585,13 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push(','); } - if sig.0.variadic { + if sig.variadic { unique_type_id.push_str("..."); } unique_type_id.push_str("|->"); - match sig.0.output { + match sig.output { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); @@ -2822,11 +2830,14 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id: UniqueTypeId, signature: &ty::PolyFnSig<'tcx>, span: Span) - -> MetadataCreationResult { - let mut signature_metadata: Vec = Vec::with_capacity(signature.0.inputs.len() + 1); + -> MetadataCreationResult +{ + let signature = ty::erase_late_bound_regions(cx.tcx(), signature); + + let mut signature_metadata: Vec = Vec::with_capacity(signature.inputs.len() + 1); // return type - signature_metadata.push(match signature.0.output { + signature_metadata.push(match signature.output { ty::FnConverging(ret_ty) => match ret_ty.sty { ty::ty_tup(ref tys) if tys.is_empty() => ptr::null_mut(), _ => type_metadata(cx, ret_ty, span) @@ -2835,7 +2846,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }); // regular arguments - for &argument_type in signature.0.inputs.iter() { + for &argument_type in signature.inputs.iter() { signature_metadata.push(type_metadata(cx, argument_type, span)); } @@ -3794,8 +3805,9 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push(']'); }, ty::ty_trait(ref trait_data) => { - push_item_name(cx, trait_data.principal_def_id(), false, output); - push_type_params(cx, trait_data.principal.0.substs, output); + let principal = ty::erase_late_bound_regions(cx.tcx(), &trait_data.principal); + push_item_name(cx, principal.def_id, false, output); + push_type_params(cx, principal.substs, output); }, ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { @@ -3810,8 +3822,9 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push_str("fn("); - if sig.0.inputs.len() > 0 { - for ¶meter_type in sig.0.inputs.iter() { + let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + if sig.inputs.len() > 0 { + for ¶meter_type in sig.inputs.iter() { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } @@ -3819,8 +3832,8 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.pop(); } - if sig.0.variadic { - if sig.0.inputs.len() > 0 { + if sig.variadic { + if sig.inputs.len() > 0 { output.push_str(", ..."); } else { output.push_str("..."); @@ -3829,7 +3842,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push(')'); - match sig.0.output { + match sig.output { ty::FnConverging(result_type) if ty::type_is_nil(result_type) => {} ty::FnConverging(result_type) => { output.push_str(" -> "); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 9221ae09df98a..33c669df73d7f 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -585,14 +585,16 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, .borrow() .get(&method_call) .map(|method| method.ty); + let method_ty = monomorphize_type(bcx, method_ty.unwrap()); let base_datum = unpack_datum!(bcx, trans(bcx, &**base)); let mut args = vec![]; start.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id))); end.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id))); - let result_ty = ty::ty_fn_ret(monomorphize_type(bcx, - method_ty.unwrap())).unwrap(); + let result_ty = // LB regions are instantiated in invoked methods + ty::assert_no_late_bound_regions( + bcx.tcx(), &ty::ty_fn_ret(method_ty)).unwrap(); let scratch = rvalue_scratch_datum(bcx, result_ty, "trans_slice"); unpack_result!(bcx, @@ -732,12 +734,16 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, .map(|method| method.ty); let elt_datum = match method_ty { Some(method_ty) => { + let method_ty = monomorphize_type(bcx, method_ty); + let base_datum = unpack_datum!(bcx, trans(bcx, base)); // Translate index expression. let ix_datum = unpack_datum!(bcx, trans(bcx, idx)); - let ref_ty = ty::ty_fn_ret(monomorphize_type(bcx, method_ty)).unwrap(); + let ref_ty = // invoked methods have LB regions instantiated: + ty::assert_no_late_bound_regions( + bcx.tcx(), &ty::ty_fn_ret(method_ty)).unwrap(); let elt_ty = match ty::deref(ref_ty, true) { None => { bcx.tcx().sess.span_bug(index_expr.span, @@ -2181,6 +2187,8 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, .get(&method_call).map(|method| method.ty); let datum = match method_ty { Some(method_ty) => { + let method_ty = monomorphize_type(bcx, method_ty); + // Overloaded. Evaluate `trans_overloaded_op`, which will // invoke the user's deref() method, which basically // converts from the `Smaht` pointer that we have into @@ -2192,7 +2200,9 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => datum }; - let ref_ty = ty::ty_fn_ret(monomorphize_type(bcx, method_ty)).unwrap(); + let ref_ty = // invoked methods have their LB regions instantiated + ty::assert_no_late_bound_regions( + ccx.tcx(), &ty::ty_fn_ret(method_ty)).unwrap(); let scratch = rvalue_scratch_datum(bcx, ref_ty, "overloaded_deref"); unpack_result!(bcx, trans_overloaded_op(bcx, expr, method_call, diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 1c9be6ae4a8ba..e58807d658881 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -43,7 +43,7 @@ use util::ppaux::Repr; struct ForeignTypes<'tcx> { /// Rust signature of the function - fn_sig: ty::PolyFnSig<'tcx>, + fn_sig: ty::FnSig<'tcx>, /// Adapter object for handling native ABI rules (trust me, you /// don't want to know) @@ -180,7 +180,7 @@ pub fn register_foreign_item_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Make sure the calling convention is right for variadic functions // (should've been caught if not in typeck) - if tys.fn_sig.0.variadic { + if tys.fn_sig.variadic { assert!(cc == llvm::CCallConv); } @@ -218,7 +218,8 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, llretptr: ValueRef, llargs_rust: &[ValueRef], passed_arg_tys: Vec>) - -> Block<'blk, 'tcx> { + -> Block<'blk, 'tcx> +{ let ccx = bcx.ccx(); let tcx = bcx.tcx(); @@ -230,9 +231,10 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ccx.tn().val_to_string(llretptr)); let (fn_abi, fn_sig) = match callee_ty.sty { - ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, fn_ty.sig.clone()), + ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, &fn_ty.sig), _ => ccx.sess().bug("trans_native_call called on non-function type") }; + let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys[]); let fn_type = cabi::compute_abi_info(ccx, llsig.llarg_tys[], @@ -387,7 +389,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debug!("llforeign_ret_ty={}", ccx.tn().type_to_string(llforeign_ret_ty)); if llrust_ret_ty == llforeign_ret_ty { - match fn_sig.0.output { + match fn_sig.output { ty::FnConverging(result_ty) => { base::store_ty(bcx, llforeign_retval, llretptr, result_ty) } @@ -635,7 +637,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }; // Push Rust return pointer, using null if it will be unused. - let rust_uses_outptr = match tys.fn_sig.0.output { + let rust_uses_outptr = match tys.fn_sig.output { ty::FnConverging(ret_ty) => type_of::return_uses_outptr(ccx, ret_ty), ty::FnDiverging => false }; @@ -668,7 +670,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, return_ty={}", ccx.tn().val_to_string(slot), ccx.tn().type_to_string(llrust_ret_ty), - tys.fn_sig.0.output.repr(tcx)); + tys.fn_sig.output.repr(tcx)); llrust_args.push(slot); return_alloca = Some(slot); } @@ -683,8 +685,8 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Build up the arguments to the call to the rust function. // Careful to adapt for cases where the native convention uses // a pointer and Rust does not or vice versa. - for i in range(0, tys.fn_sig.0.inputs.len()) { - let rust_ty = tys.fn_sig.0.inputs[i]; + for i in range(0, tys.fn_sig.inputs.len()) { + let rust_ty = tys.fn_sig.inputs[i]; let llrust_ty = tys.llsig.llarg_tys[i]; let rust_indirect = type_of::arg_is_indirect(ccx, rust_ty); let llforeign_arg_ty = tys.fn_ty.arg_tys[i]; @@ -829,10 +831,11 @@ pub fn link_name(i: &ast::ForeignItem) -> InternedString { /// because foreign functions just plain ignore modes. They also don't pass aggregate values by /// pointer like we do. fn foreign_signature<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, - fn_sig: &ty::PolyFnSig<'tcx>, arg_tys: &[Ty<'tcx>]) + fn_sig: &ty::FnSig<'tcx>, + arg_tys: &[Ty<'tcx>]) -> LlvmSignature { let llarg_tys = arg_tys.iter().map(|&arg| arg_type_of(ccx, arg)).collect(); - let (llret_ty, ret_def) = match fn_sig.0.output { + let (llret_ty, ret_def) = match fn_sig.output { ty::FnConverging(ret_ty) => (type_of::arg_type_of(ccx, ret_ty), !return_type_is_void(ccx, ret_ty)), ty::FnDiverging => @@ -853,10 +856,11 @@ fn foreign_types_for_id<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> ForeignTypes<'tcx> { let fn_sig = match ty.sty { - ty::ty_bare_fn(_, ref fn_ty) => fn_ty.sig.clone(), + ty::ty_bare_fn(_, ref fn_ty) => &fn_ty.sig, _ => ccx.sess().bug("foreign_types_for_fn_ty called on non-function type") }; - let llsig = foreign_signature(ccx, &fn_sig, fn_sig.0.inputs.as_slice()); + let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); + let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice()); let fn_ty = cabi::compute_abi_info(ccx, llsig.llarg_tys[], llsig.llret_ty, @@ -916,7 +920,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T llargument_tys.push(llarg_ty); } - if tys.fn_sig.0.variadic { + if tys.fn_sig.variadic { Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty) } else { Type::func(llargument_tys[], &llreturn_ty) diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 2fd9031fdfe4c..8019ae822e65f 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -212,7 +212,8 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, dtor_did: ast::DefId, class_did: ast::DefId, substs: &subst::Substs<'tcx>) - -> Block<'blk, 'tcx> { + -> Block<'blk, 'tcx> +{ let repr = adt::represent_type(bcx.ccx(), t); // Find and call the actual destructor @@ -228,8 +229,9 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let fty = ty::lookup_item_type(bcx.tcx(), dtor_did).ty.subst(bcx.tcx(), substs); let self_ty = match fty.sty { ty::ty_bare_fn(_, ref f) => { - assert!(f.sig.0.inputs.len() == 1); - f.sig.0.inputs[0] + let sig = ty::erase_late_bound_regions(bcx.tcx(), &f.sig); + assert!(sig.inputs.len() == 1); + sig.inputs[0] } _ => bcx.sess().bug(format!("Expected function type, found {}", bcx.ty_to_string(fty))[]) diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 6e71653891181..ed75445b9939b 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -150,14 +150,16 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, dest: expr::Dest, substs: subst::Substs<'tcx>, call_info: NodeInfo) - -> Result<'blk, 'tcx> { - + -> Result<'blk, 'tcx> +{ let fcx = bcx.fcx; let ccx = fcx.ccx; let tcx = bcx.tcx(); let ret_ty = match callee_ty.sty { - ty::ty_bare_fn(_, ref f) => f.sig.0.output, + ty::ty_bare_fn(_, ref f) => { + ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()) + } _ => panic!("expected bare_fn in trans_intrinsic_call") }; let foreign_item = tcx.map.expect_foreign_item(node); diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index f6d69959dadf9..362fca881b711 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -477,13 +477,19 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Load the function from the vtable and cast it to the expected type. debug!("(translating trait callee) loading method"); + // Replace the self type (&Self or Box) with an opaque pointer. let llcallee_ty = match callee_ty.sty { ty::ty_bare_fn(_, ref f) if f.abi == Rust || f.abi == RustCall => { + let fake_sig = + ty::Binder(ty::FnSig { + inputs: f.sig.0.inputs.slice_from(1).to_vec(), + output: f.sig.0.output, + variadic: f.sig.0.variadic, + }); type_of_rust_fn(ccx, Some(Type::i8p(ccx)), - f.sig.0.inputs.slice_from(1), - f.sig.0.output, + &fake_sig, f.abi) } _ => { @@ -557,7 +563,8 @@ pub fn trans_object_shim<'a, 'tcx>( // Upcast to the trait in question and extract out the substitutions. let upcast_trait_ref = traits::upcast(ccx.tcx(), object_trait_ref.clone(), trait_id).unwrap(); - let object_substs = upcast_trait_ref.substs().clone().erase_regions(); + let upcast_trait_ref = ty::erase_late_bound_regions(tcx, &upcast_trait_ref); + let object_substs = upcast_trait_ref.substs.clone().erase_regions(); debug!("trans_object_shim: object_substs={}", object_substs.repr(tcx)); // Lookup the type of this method as deeclared in the trait and apply substitutions. @@ -579,6 +586,8 @@ pub fn trans_object_shim<'a, 'tcx>( let llfn = decl_internal_rust_fn(ccx, method_bare_fn_ty, function_name.as_slice()); + let sig = ty::erase_late_bound_regions(ccx.tcx(), &fty.sig); + // let block_arena = TypedArena::new(); let empty_substs = Substs::trans_empty(); @@ -586,11 +595,11 @@ pub fn trans_object_shim<'a, 'tcx>( llfn, ast::DUMMY_NODE_ID, false, - fty.sig.0.output, + sig.output, &empty_substs, None, &block_arena); - let mut bcx = init_function(&fcx, false, fty.sig.0.output); + let mut bcx = init_function(&fcx, false, sig.output); // the first argument (`self`) will be a trait object let llobject = get_param(fcx.llfn, fcx.arg_pos(0) as u32); @@ -603,18 +612,18 @@ pub fn trans_object_shim<'a, 'tcx>( match fty.abi { RustCall => { // unpack the tuple to extract the input type arguments: - match fty.sig.0.inputs[1].sty { + match sig.inputs[1].sty { ty::ty_tup(ref tys) => tys.as_slice(), _ => { bcx.sess().bug( format!("rust-call expects a tuple not {}", - fty.sig.0.inputs[1].repr(tcx)).as_slice()); + sig.inputs[1].repr(tcx)).as_slice()); } } } _ => { // skip the self parameter: - fty.sig.0.inputs.slice_from(1) + sig.inputs.slice_from(1) } }; @@ -631,9 +640,12 @@ pub fn trans_object_shim<'a, 'tcx>( assert!(!fcx.needs_ret_allocas); + let sig = + ty::erase_late_bound_regions(bcx.tcx(), &fty.sig); + let dest = fcx.llretslotptr.get().map( - |_| expr::SaveIn(fcx.get_ret_slot(bcx, fty.sig.0.output, "ret_slot"))); + |_| expr::SaveIn(fcx.get_ret_slot(bcx, sig.output, "ret_slot"))); let method_offset_in_vtable = traits::get_vtable_index_of_object_method(bcx.tcx(), @@ -653,7 +665,7 @@ pub fn trans_object_shim<'a, 'tcx>( ArgVals(llargs.as_slice()), dest).bcx; - finish_fn(&fcx, bcx, fty.sig.0.output); + finish_fn(&fcx, bcx, sig.output); llfn } diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 3e499ea8498fb..64b83c48729d4 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -17,7 +17,7 @@ use trans::adt; use trans::common::*; use trans::foreign; use trans::machine; -use middle::ty::{self, Ty}; +use middle::ty::{self, RegionEscape, Ty}; use util::ppaux; use util::ppaux::Repr; @@ -99,18 +99,21 @@ pub fn untuple_arguments_if_necessary<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, llenvironment_type: Option, - inputs: &[Ty<'tcx>], - output: ty::FnOutput<'tcx>, + sig: &ty::Binder>, abi: abi::Abi) - -> Type { + -> Type +{ + let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + assert!(!sig.variadic); // rust fns are never variadic + let mut atys: Vec = Vec::new(); // First, munge the inputs, if this has the `rust-call` ABI. - let inputs = untuple_arguments_if_necessary(cx, inputs, abi); + let inputs = untuple_arguments_if_necessary(cx, sig.inputs.as_slice(), abi); // Arg 0: Output pointer. // (if the output type is non-immediate) - let lloutputtype = match output { + let lloutputtype = match sig.output { ty::FnConverging(output) => { let use_out_pointer = return_uses_outptr(cx, output); let lloutputtype = arg_type_of(cx, output); @@ -147,11 +150,7 @@ pub fn type_of_fn_from_ty<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fty: Ty<'tcx>) // FIXME(#19925) once fn item types are // zero-sized, we'll need to do something here if f.abi == abi::Rust || f.abi == abi::RustCall { - type_of_rust_fn(cx, - None, - f.sig.0.inputs.as_slice(), - f.sig.0.output, - f.abi) + type_of_rust_fn(cx, None, &f.sig, f.abi) } else { foreign::lltype_for_foreign_fn(cx, fty) } @@ -279,12 +278,14 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { debug!("type_of {} {}", t.repr(cx.tcx()), t.sty); + assert!(!t.has_escaping_regions()); + // Replace any typedef'd types with their equivalent non-typedef // type. This ensures that all LLVM nominal types that contain // Rust types are defined as the same LLVM types. If we don't do // this then, e.g. `Option<{myfield: bool}>` would be a different // type than `Option`. - let t_norm = ty::normalize_ty(cx.tcx(), t); + let t_norm = normalize_ty(cx.tcx(), t); if t != t_norm { let llty = type_of(cx, t_norm); diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 80e7e70605956..8cd181c37747d 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -505,9 +505,10 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &ast::Pat, let ctor_scheme = ty::lookup_item_type(tcx, enum_def); let path_scheme = if ty::is_fn_ty(ctor_scheme.ty) { + let fn_ret = ty::assert_no_late_bound_regions(tcx, &ty::ty_fn_ret(ctor_scheme.ty)); ty::TypeScheme { - ty: ty::ty_fn_ret(ctor_scheme.ty).unwrap(), - ..ctor_scheme + ty: fn_ret.unwrap(), + generics: ctor_scheme.generics, } } else { ctor_scheme diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1b51434a58cc1..d9afa2da3b5ee 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2317,7 +2317,9 @@ fn make_overloaded_lvalue_return_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, { match method { Some(method) => { - let ref_ty = ty::ty_fn_ret(method.ty); + let ref_ty = // invoked methods have all LB regions instantiated + ty::assert_no_late_bound_regions( + fcx.tcx(), &ty::ty_fn_ret(method.ty)); match method_call { Some(method_call) => { fcx.inh.method_map.borrow_mut().insert(method_call, @@ -2448,7 +2450,11 @@ fn try_overloaded_slice_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let method_ty = method.ty; make_overloaded_lvalue_return_type(fcx, Some(method_call), Some(method)); - let result_ty = ty::ty_fn_ret(method_ty); + let result_ty = + // invoked methods have LB regions instantiated + ty::assert_no_late_bound_regions(fcx.tcx(), + &ty::ty_fn_ret(method_ty)); + let result_ty = match result_ty { ty::FnConverging(result_ty) => result_ty, ty::FnDiverging => { diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index c7df5ed8453fd..4badfc03858a4 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -582,7 +582,9 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { Some(method) => { constrain_call(rcx, expr, Some(&**base), None::.iter(), true); - ty::ty_fn_ret(method.ty).unwrap() + let fn_ret = // late-bound regions in overloaded method calls are instantiated + ty::assert_no_late_bound_regions(rcx.tcx(), &ty::ty_fn_ret(method.ty)); + fn_ret.unwrap() } None => rcx.resolve_node_type(base.id) }; diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index d4a5bda5f97f9..300f72960848e 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -416,7 +416,13 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, match variant.node.kind { ast::TupleVariantKind(ref args) if args.len() > 0 => { let ctor_ty = ty::node_id_to_type(fcx.tcx(), variant.node.id); - let arg_tys = ty::ty_fn_args(ctor_ty); + + // the regions in the argument types come from the + // enum def'n, and hence will all be early bound + let arg_tys = + ty::assert_no_late_bound_regions( + fcx.tcx(), &ty::ty_fn_args(ctor_ty)); + AdtVariant { fields: args.iter().enumerate().map(|(index, arg)| { let arg_ty = arg_tys[index]; diff --git a/src/test/run-pass/issue-20644.rs b/src/test/run-pass/issue-20644.rs new file mode 100644 index 0000000000000..4a57ed56594b1 --- /dev/null +++ b/src/test/run-pass/issue-20644.rs @@ -0,0 +1,35 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// A reduced version of the rustbook ice. The problem this encountered +// had to do with trans ignoring binders. + +#![feature(slicing_syntax)] +#![feature(associated_types)] +#![feature(macro_rules)] + +use std::iter; +use std::os; +use std::io::File; + +#[allow(unused)] +pub fn parse_summary(_: R, _: &Path) { + let path_from_root = Path::new(""); + Path::new(iter::repeat("../") + .take(path_from_root.components().count() - 1) + .collect::()); + } + +fn main() { + let cwd = os::getcwd().unwrap(); + let src = cwd.clone(); + let summary = File::open(&src.join("SUMMARY.md")); + let _ = parse_summary(summary, &src); +} From 25eada15740fbe12ee2cae7fc6fe8e2c228b699d Mon Sep 17 00:00:00 2001 From: Dylan Ede Date: Tue, 6 Jan 2015 16:36:30 +0000 Subject: [PATCH 20/49] [breaking change] Revert Entry behaviour to take keys by value. --- src/libcollections/btree/map.rs | 34 +++++++------- src/librustc/lint/builtin.rs | 2 +- src/librustc/metadata/loader.rs | 2 +- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/infer/freshen.rs | 2 +- .../middle/infer/region_inference/graphviz.rs | 2 +- src/librustc/middle/traits/fulfill.rs | 4 +- src/librustc/middle/ty.rs | 4 +- src/librustc/session/config.rs | 2 +- src/librustc_resolve/lib.rs | 8 ++-- src/librustc_typeck/check/_match.rs | 2 +- src/librustdoc/html/render.rs | 6 +-- src/librustdoc/lib.rs | 2 +- src/libstd/collections/hash/map.rs | 45 +++++++++---------- src/libstd/collections/mod.rs | 4 +- src/libsyntax/ext/mtwt.rs | 4 +- src/libsyntax/ext/tt/macro_parser.rs | 2 +- src/libtest/stats.rs | 2 +- 18 files changed, 60 insertions(+), 69 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index b85ea65f5ce58..6e8b1a662ce76 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -19,7 +19,7 @@ pub use self::Entry::*; use core::prelude::*; -use core::borrow::{BorrowFrom, ToOwned}; +use core::borrow::BorrowFrom; use core::cmp::Ordering; use core::default::Default; use core::fmt::Show; @@ -130,17 +130,17 @@ pub struct Values<'a, K: 'a, V: 'a> { #[stable] /// A view into a single entry in a map, which may either be vacant or occupied. -pub enum Entry<'a, Q: ?Sized +'a, K:'a, V:'a> { +pub enum Entry<'a, K:'a, V:'a> { /// A vacant Entry - Vacant(VacantEntry<'a, Q, K, V>), + Vacant(VacantEntry<'a, K, V>), /// An occupied Entry Occupied(OccupiedEntry<'a, K, V>), } #[stable] /// A vacant Entry. -pub struct VacantEntry<'a, Q: ?Sized +'a, K:'a, V:'a> { - key: &'a Q, +pub struct VacantEntry<'a, K:'a, V:'a> { + key: K, stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>, } @@ -1111,10 +1111,10 @@ impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> { #[stable] impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {} -impl<'a, Q: ?Sized, K: Ord, V> Entry<'a, Q, K, V> { +impl<'a, K: Ord, V> Entry<'a, K, V> { #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant - pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> { + pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> { match self { Occupied(entry) => Ok(entry.into_mut()), Vacant(entry) => Err(entry), @@ -1122,12 +1122,12 @@ impl<'a, Q: ?Sized, K: Ord, V> Entry<'a, Q, K, V> { } } -impl<'a, Q: ?Sized + ToOwned, K: Ord, V> VacantEntry<'a, Q, K, V> { +impl<'a, K: Ord, V> VacantEntry<'a, K, V> { #[stable] /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it. pub fn insert(self, value: V) -> &'a mut V { - self.stack.insert(self.key.to_owned(), value) + self.stack.insert(self.key, value) } } @@ -1362,14 +1362,12 @@ impl BTreeMap { /// ``` /// The key must have the same ordering before or after `.to_owned()` is called. #[stable] - pub fn entry<'a, Q: ?Sized>(&'a mut self, mut key: &'a Q) -> Entry<'a, Q, K, V> - where Q: Ord + ToOwned - { + pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> { // same basic logic of `swap` and `pop`, blended together let mut stack = stack::PartialSearchStack::new(self); loop { let result = stack.with(move |pusher, node| { - return match Node::search(node, key) { + return match Node::search(node, &key) { Found(handle) => { // Perfect match Finished(Occupied(OccupiedEntry { @@ -1412,7 +1410,7 @@ impl BTreeMap { #[cfg(test)] mod test { use prelude::*; - use std::borrow::{ToOwned, BorrowFrom}; + use std::borrow::BorrowFrom; use super::{BTreeMap, Occupied, Vacant}; @@ -1562,7 +1560,7 @@ mod test { let mut map: BTreeMap = xs.iter().map(|&x| x).collect(); // Existing key (insert) - match map.entry(&1) { + match map.entry(1) { Vacant(_) => unreachable!(), Occupied(mut view) => { assert_eq!(view.get(), &10); @@ -1574,7 +1572,7 @@ mod test { // Existing key (update) - match map.entry(&2) { + match map.entry(2) { Vacant(_) => unreachable!(), Occupied(mut view) => { let v = view.get_mut(); @@ -1585,7 +1583,7 @@ mod test { assert_eq!(map.len(), 6); // Existing key (take) - match map.entry(&3) { + match map.entry(3) { Vacant(_) => unreachable!(), Occupied(view) => { assert_eq!(view.remove(), 30); @@ -1596,7 +1594,7 @@ mod test { // Inexistent key (insert) - match map.entry(&10) { + match map.entry(10) { Occupied(_) => unreachable!(), Vacant(view) => { assert_eq!(*view.insert(1000), 1000); diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 425e34cd9f042..a510a194c9870 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1328,7 +1328,7 @@ impl UnusedMut { let ident = path1.node; if let ast::BindByValue(ast::MutMutable) = mode { if !token::get_ident(ident).get().starts_with("_") { - match mutables.entry(&ident.name.uint()) { + match mutables.entry(ident.name.uint()) { Vacant(entry) => { entry.insert(vec![id]); }, Occupied(mut entry) => { entry.get_mut().push(id); }, } diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 7c0645b4ca204..d02277062863a 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -400,7 +400,7 @@ impl<'a> Context<'a> { info!("lib candidate: {}", path.display()); let hash_str = hash.to_string(); - let slot = candidates.entry(&hash_str).get().unwrap_or_else( + let slot = candidates.entry(hash_str).get().unwrap_or_else( |vacant_entry| vacant_entry.insert((HashSet::new(), HashSet::new()))); let (ref mut rlibs, ref mut dylibs) = *slot; if rlib { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 32482fce4daa8..25967fb878463 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -311,7 +311,7 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P { ast::ExprCall(ref callee, ref args) => { let def = tcx.def_map.borrow()[callee.id].clone(); - if let Vacant(entry) = tcx.def_map.borrow_mut().entry(&expr.id) { + if let Vacant(entry) = tcx.def_map.borrow_mut().entry(expr.id) { entry.insert(def); } let path = match def { diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs index 608ae31475327..02c52f8296761 100644 --- a/src/librustc/middle/infer/freshen.rs +++ b/src/librustc/middle/infer/freshen.rs @@ -66,7 +66,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> { None => { } } - match self.freshen_map.entry(&key) { + match self.freshen_map.entry(key) { Entry::Occupied(entry) => *entry.get(), Entry::Vacant(entry) => { let index = self.freshen_count; diff --git a/src/librustc/middle/infer/region_inference/graphviz.rs b/src/librustc/middle/infer/region_inference/graphviz.rs index 98c69962bc288..8135c1ca13792 100644 --- a/src/librustc/middle/infer/region_inference/graphviz.rs +++ b/src/librustc/middle/infer/region_inference/graphviz.rs @@ -137,7 +137,7 @@ impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> { let mut node_ids = FnvHashMap::new(); { let mut add_node = |&mut : node| { - if let Vacant(e) = node_ids.entry(&node) { + if let Vacant(e) = node_ids.entry(node) { e.insert(i); i += 1; } diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index c2327adece8e0..1f37fc357b8ec 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -437,11 +437,9 @@ fn register_region_obligation<'tcx>(tcx: &ty::ctxt<'tcx>, debug!("register_region_obligation({})", region_obligation.repr(tcx)); - let body_id = region_obligation.cause.body_id; - match region_obligations.entry(&body_id) { + match region_obligations.entry(region_obligation.cause.body_id) { Vacant(entry) => { entry.insert(vec![region_obligation]); }, Occupied(mut entry) => { entry.get_mut().push(region_obligation); }, } } - diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c359233eca173..652b9b294fa3b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -5584,7 +5584,7 @@ pub fn lookup_field_type<'tcx>(tcx: &ctxt<'tcx>, node_id_to_type(tcx, id.node) } else { let mut tcache = tcx.tcache.borrow_mut(); - let pty = tcache.entry(&id).get().unwrap_or_else( + let pty = tcache.entry(id).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(csearch::get_field_type(tcx, struct_id, id))); pty.ty }; @@ -6747,7 +6747,7 @@ pub fn replace_late_bound_regions<'tcx, T, F>( debug!("region={}", region.repr(tcx)); match region { ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => { - * map.entry(&br).get().unwrap_or_else( + * map.entry(br).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(mapf(br, debruijn))) } _ => { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 138f648049c73..7928dad970f03 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1115,7 +1115,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { None => early_error("--extern value must be of the format `foo=bar`"), }; - match externs.entry(&name.to_string()) { + match externs.entry(name.to_string()) { Vacant(entry) => { entry.insert(vec![location.to_string()]); }, Occupied(mut entry) => { entry.get_mut().push(location.to_string()); }, } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 58102fe5629d9..1927f204bc69b 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1701,7 +1701,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let is_public = import_directive.is_public; let mut import_resolutions = module_.import_resolutions.borrow_mut(); - let dest_import_resolution = import_resolutions.entry(&name).get().unwrap_or_else( + let dest_import_resolution = import_resolutions.entry(name).get().unwrap_or_else( |vacant_entry| { // Create a new import resolution from this child. vacant_entry.insert(ImportResolution::new(id, is_public)) @@ -2639,14 +2639,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { def = DefUpvar(node_id, function_id, last_proc_body_id); let mut seen = self.freevars_seen.borrow_mut(); - let seen = match seen.entry(&function_id) { + let seen = match seen.entry(function_id) { Occupied(v) => v.into_mut(), Vacant(v) => v.insert(NodeSet::new()), }; if seen.contains(&node_id) { continue; } - match self.freevars.borrow_mut().entry(&function_id) { + match self.freevars.borrow_mut().entry(function_id) { Occupied(v) => v.into_mut(), Vacant(v) => v.insert(vec![]), }.push(Freevar { def: prev_def, span: span }); @@ -4723,7 +4723,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { "Import should only be used for `use` directives"); self.last_private.insert(node_id, lp); - match self.def_map.borrow_mut().entry(&node_id) { + match self.def_map.borrow_mut().entry(node_id) { // Resolve appears to "resolve" the same ID multiple // times, so here is a sanity check it at least comes to // the same conclusion! - nmatsakis diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 80e7e70605956..44dc1d11c0f89 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -603,7 +603,7 @@ pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, // Typecheck each field. for &Spanned { node: ref field, span } in fields.iter() { - let field_type = match used_fields.entry(&field.ident.name) { + let field_type = match used_fields.entry(field.ident.name) { Occupied(occupied) => { span_err!(tcx.sess, span, E0025, "field `{}` bound multiple times in the pattern", diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index ddb14d6944b9d..5aa96cedb5c3a 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -821,7 +821,7 @@ impl DocFolder for Cache { if let clean::ImplItem(ref i) = item.inner { match i.trait_ { Some(clean::ResolvedPath{ did, .. }) => { - let v = self.implementors.entry(&did).get().unwrap_or_else( + let v = self.implementors.entry(did).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(Vec::with_capacity(1))); v.push(Implementor { def_id: item.def_id, @@ -1011,7 +1011,7 @@ impl DocFolder for Cache { }; if let Some(did) = did { - let v = self.impls.entry(&did).get().unwrap_or_else( + let v = self.impls.entry(did).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(Vec::with_capacity(1))); v.push(Impl { impl_: i, @@ -1260,7 +1260,7 @@ impl Context { Some(ref s) => s.to_string(), }; let short = short.to_string(); - let v = map.entry(&short).get().unwrap_or_else( + let v = map.entry(short).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(Vec::with_capacity(1))); v.push(myname); } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 6e42c50f974c5..98f66fa487820 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -330,7 +330,7 @@ fn parse_externs(matches: &getopts::Matches) -> Result { } }; let name = name.to_string(); - let locs = externs.entry(&name).get().unwrap_or_else( + let locs = externs.entry(name).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(Vec::with_capacity(1))); locs.push(location.to_string()); } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index a3fc38c34e84f..ae53bc615992c 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -14,7 +14,7 @@ use self::Entry::*; use self::SearchResult::*; use self::VacantEntryState::*; -use borrow::{BorrowFrom, ToOwned}; +use borrow::BorrowFrom; use clone::Clone; use cmp::{max, Eq, PartialEq}; use default::Default; @@ -922,14 +922,12 @@ impl, V, S, H: Hasher> HashMap { #[stable] /// Gets the given key's corresponding entry in the map for in-place manipulation. - /// Regardless of whether or not `to_owned()` has been called, the key must hash the same way. - pub fn entry<'a, Q: ?Sized>(&'a mut self, key: &'a Q) -> Entry<'a, Q, K, V> - where Q: Eq + Hash + ToOwned + pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> { // Gotta resize now. self.reserve(1); - let hash = self.make_hash(key); + let hash = self.make_hash(&key); search_entry_hashed(&mut self.table, hash, key) } @@ -1142,9 +1140,8 @@ impl, V, S, H: Hasher> HashMap { } } -fn search_entry_hashed<'a, K, V, Q: ?Sized>(table: &'a mut RawTable, hash: SafeHash, k: &'a Q) - -> Entry<'a, Q, K, V> - where Q: Eq + ToOwned +fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable, hash: SafeHash, k: K) + -> Entry<'a, K, V> { // Worst case, we'll find one empty bucket among `size + 1` buckets. let size = table.size(); @@ -1167,7 +1164,7 @@ fn search_entry_hashed<'a, K, V, Q: ?Sized>(table: &'a mut RawTable, hash: // hash matches? if bucket.hash() == hash { // key matches? - if *k == *BorrowFrom::borrow_from(bucket.read().0) { + if k == *bucket.read().0 { return Occupied(OccupiedEntry{ elem: bucket, }); @@ -1331,19 +1328,19 @@ pub struct OccupiedEntry<'a, K: 'a, V: 'a> { #[stable] /// A view into a single empty location in a HashMap -pub struct VacantEntry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> { +pub struct VacantEntry<'a, K: 'a, V: 'a> { hash: SafeHash, - key: &'a Q, + key: K, elem: VacantEntryState>, } #[stable] /// A view into a single location in a map, which may be vacant or occupied -pub enum Entry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> { +pub enum Entry<'a, K: 'a, V: 'a> { /// An occupied Entry Occupied(OccupiedEntry<'a, K, V>), /// A vacant Entry - Vacant(VacantEntry<'a, Q, K, V>), + Vacant(VacantEntry<'a, K, V>), } /// Possible states of a VacantEntry @@ -1409,10 +1406,10 @@ impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> { } } -impl<'a, Q: ?Sized, K, V> Entry<'a, Q, K, V> { +impl<'a, K, V> Entry<'a, K, V> { #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant - pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> { + pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> { match self { Occupied(entry) => Ok(entry.into_mut()), Vacant(entry) => Err(entry), @@ -1455,17 +1452,17 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { } } -impl<'a, Q: ?Sized + 'a + ToOwned, K: 'a, V: 'a> VacantEntry<'a, Q, K, V> { +impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { #[stable] /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it pub fn insert(self, value: V) -> &'a mut V { match self.elem { NeqElem(bucket, ib) => { - robin_hood(bucket, ib, self.hash, self.key.to_owned(), value) + robin_hood(bucket, ib, self.hash, self.key, value) } NoElem(bucket) => { - bucket.put(self.hash, self.key.to_owned(), value).into_mut_refs().1 + bucket.put(self.hash, self.key, value).into_mut_refs().1 } } } @@ -1497,8 +1494,6 @@ mod test_map { use super::HashMap; use super::Entry::{Occupied, Vacant}; use iter::{range_inclusive, range_step_inclusive, repeat}; - use borrow::ToOwned; - use hash; use cell::RefCell; use rand::{weak_rng, Rng}; @@ -2092,7 +2087,7 @@ mod test_map { let mut map: HashMap = xs.iter().map(|&x| x).collect(); // Existing key (insert) - match map.entry(&1) { + match map.entry(1) { Vacant(_) => unreachable!(), Occupied(mut view) => { assert_eq!(view.get(), &10); @@ -2104,7 +2099,7 @@ mod test_map { // Existing key (update) - match map.entry(&2) { + match map.entry(2) { Vacant(_) => unreachable!(), Occupied(mut view) => { let v = view.get_mut(); @@ -2116,7 +2111,7 @@ mod test_map { assert_eq!(map.len(), 6); // Existing key (take) - match map.entry(&3) { + match map.entry(3) { Vacant(_) => unreachable!(), Occupied(view) => { assert_eq!(view.remove(), 30); @@ -2127,7 +2122,7 @@ mod test_map { // Inexistent key (insert) - match map.entry(&10) { + match map.entry(10) { Occupied(_) => unreachable!(), Vacant(view) => { assert_eq!(*view.insert(1000), 1000); @@ -2158,7 +2153,7 @@ mod test_map { for i in range(0u, 1000) { let x = rng.gen_range(-10, 10); - match m.entry(&x) { + match m.entry(x) { Vacant(_) => {}, Occupied(e) => { println!("{}: remove {}", i, x); diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index ef9d28bbbb2e8..9b2a4926bcb92 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -255,7 +255,7 @@ //! let message = "she sells sea shells by the sea shore"; //! //! for c in message.chars() { -//! match count.entry(&c) { +//! match count.entry(c) { //! Vacant(entry) => { entry.insert(1u); }, //! Occupied(mut entry) => *entry.get_mut() += 1, //! } @@ -290,7 +290,7 @@ //! for id in orders.into_iter() { //! // If this is the first time we've seen this customer, initialize them //! // with no blood alcohol. Otherwise, just retrieve them. -//! let person = match blood_alcohol.entry(&id) { +//! let person = match blood_alcohol.entry(id) { //! Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}), //! Occupied(entry) => entry.into_mut(), //! }; diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index 4075b208f7873..19af198bffa82 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -66,7 +66,7 @@ pub fn apply_mark(m: Mrk, ctxt: SyntaxContext) -> SyntaxContext { /// Extend a syntax context with a given mark and sctable (explicit memoization) fn apply_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxContext { let key = (ctxt, m); - * table.mark_memo.borrow_mut().entry(&key).get().unwrap_or_else( + * table.mark_memo.borrow_mut().entry(key).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt)))) } @@ -84,7 +84,7 @@ fn apply_rename_internal(id: Ident, table: &SCTable) -> SyntaxContext { let key = (ctxt, id, to); - * table.rename_memo.borrow_mut().entry(&key).get().unwrap_or_else( + * table.rename_memo.borrow_mut().entry(key).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt)))) } diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 1438d15255495..88f79c504d757 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -219,7 +219,7 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) } } &TtToken(sp, MatchNt(bind_name, _, _, _)) => { - match ret_val.entry(&bind_name) { + match ret_val.entry(bind_name) { Vacant(spot) => { spot.insert(res[*idx].clone()); *idx += 1; diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index bdc05a50301d5..8d79460ec1712 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -444,7 +444,7 @@ pub fn freq_count(mut iter: T) -> hash_map::HashMap { let mut map: hash_map::HashMap = hash_map::HashMap::new(); for elem in iter { - match map.entry(&elem) { + match map.entry(elem) { Occupied(mut entry) => { *entry.get_mut() += 1; }, Vacant(entry) => { entry.insert(1); }, } From 169fbed25179f223b730e1db5739e4a5a408ef31 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 6 Jan 2015 10:25:12 -0800 Subject: [PATCH 21/49] std: Revert stability of Entry-based APIs There's been some debate over the precise form that these APIs should take, and they've undergone some changes recently, so these APIs are going to be left unstable for now to be fleshed out during the next release cycle. --- src/libcollections/btree/map.rs | 20 ++++++++++---------- src/libstd/collections/hash/map.rs | 18 +++++++----------- 2 files changed, 17 insertions(+), 21 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 6e8b1a662ce76..0a0bb5b876574 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -128,8 +128,8 @@ pub struct Values<'a, K: 'a, V: 'a> { inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V> } -#[stable] /// A view into a single entry in a map, which may either be vacant or occupied. +#[unstable = "precise API still under development"] pub enum Entry<'a, K:'a, V:'a> { /// A vacant Entry Vacant(VacantEntry<'a, K, V>), @@ -137,15 +137,15 @@ pub enum Entry<'a, K:'a, V:'a> { Occupied(OccupiedEntry<'a, K, V>), } -#[stable] /// A vacant Entry. +#[unstable = "precise API still under development"] pub struct VacantEntry<'a, K:'a, V:'a> { key: K, stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>, } -#[stable] /// An occupied Entry. +#[unstable = "precise API still under development"] pub struct OccupiedEntry<'a, K:'a, V:'a> { stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>, } @@ -1123,43 +1123,43 @@ impl<'a, K: Ord, V> Entry<'a, K, V> { } impl<'a, K: Ord, V> VacantEntry<'a, K, V> { - #[stable] /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn insert(self, value: V) -> &'a mut V { self.stack.insert(self.key, value) } } impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { - #[stable] /// Gets a reference to the value in the entry. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn get(&self) -> &V { self.stack.peek() } - #[stable] /// Gets a mutable reference to the value in the entry. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn get_mut(&mut self) -> &mut V { self.stack.peek_mut() } - #[stable] /// Converts the entry into a mutable reference to its value. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn into_mut(self) -> &'a mut V { self.stack.into_top() } - #[stable] /// Sets the value of the entry with the OccupiedEntry's key, /// and returns the entry's old value. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn insert(&mut self, mut value: V) -> V { mem::swap(self.stack.peek_mut(), &mut value); value } - #[stable] /// Takes the value of the entry out of the map, and returns it. + #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] pub fn remove(self) -> V { self.stack.remove() } @@ -1361,7 +1361,7 @@ impl BTreeMap { /// assert_eq!(count["a"], 3u); /// ``` /// The key must have the same ordering before or after `.to_owned()` is called. - #[stable] + #[unstable = "precise API still under development"] pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> { // same basic logic of `swap` and `pop`, blended together let mut stack = stack::PartialSearchStack::new(self); diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index ae53bc615992c..a01158fb1ed27 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -920,8 +920,8 @@ impl, V, S, H: Hasher> HashMap { } } - #[stable] /// Gets the given key's corresponding entry in the map for in-place manipulation. + #[unstable = "precise API still being fleshed out"] pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> { // Gotta resize now. @@ -1320,22 +1320,22 @@ pub struct Drain<'a, K: 'a, V: 'a> { > } -#[stable] /// A view into a single occupied location in a HashMap +#[unstable = "precise API still being fleshed out"] pub struct OccupiedEntry<'a, K: 'a, V: 'a> { elem: FullBucket>, } -#[stable] /// A view into a single empty location in a HashMap +#[unstable = "precise API still being fleshed out"] pub struct VacantEntry<'a, K: 'a, V: 'a> { hash: SafeHash, key: K, elem: VacantEntryState>, } -#[stable] /// A view into a single location in a map, which may be vacant or occupied +#[unstable = "precise API still being fleshed out"] pub enum Entry<'a, K: 'a, V: 'a> { /// An occupied Entry Occupied(OccupiedEntry<'a, K, V>), @@ -1406,8 +1406,8 @@ impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> { } } +#[unstable = "matches collection reform v2 specification, waiting for dust to settle"] impl<'a, K, V> Entry<'a, K, V> { - #[unstable = "matches collection reform v2 specification, waiting for dust to settle"] /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> { match self { @@ -1417,27 +1417,24 @@ impl<'a, K, V> Entry<'a, K, V> { } } +#[unstable = "matches collection reform v2 specification, waiting for dust to settle"] impl<'a, K, V> OccupiedEntry<'a, K, V> { - #[stable] /// Gets a reference to the value in the entry pub fn get(&self) -> &V { self.elem.read().1 } - #[stable] /// Gets a mutable reference to the value in the entry pub fn get_mut(&mut self) -> &mut V { self.elem.read_mut().1 } - #[stable] /// Converts the OccupiedEntry into a mutable reference to the value in the entry /// with a lifetime bound to the map itself pub fn into_mut(self) -> &'a mut V { self.elem.into_mut_refs().1 } - #[stable] /// Sets the value of the entry, and returns the entry's old value pub fn insert(&mut self, mut value: V) -> V { let old_value = self.get_mut(); @@ -1445,15 +1442,14 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { value } - #[stable] /// Takes the value out of the entry, and returns it pub fn remove(self) -> V { pop_internal(self.elem).1 } } +#[unstable = "matches collection reform v2 specification, waiting for dust to settle"] impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { - #[stable] /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it pub fn insert(self, value: V) -> &'a mut V { From abcbe276954525bc7902a5a20762a580d5ed4ea2 Mon Sep 17 00:00:00 2001 From: Corey Richardson Date: Fri, 5 Dec 2014 18:11:46 -0800 Subject: [PATCH 22/49] syntax/rustc: implement isize/usize --- src/librustc/lint/builtin.rs | 22 +++++++++++----------- src/librustc/metadata/tydecode.rs | 4 ++-- src/librustc/metadata/tyencode.rs | 4 ++-- src/librustc/middle/const_eval.rs | 4 ++-- src/librustc/middle/ty.rs | 14 +++++++------- src/librustc_resolve/lib.rs | 10 ++++++---- src/librustc_trans/trans/base.rs | 4 ++-- src/librustc_trans/trans/debuginfo.rs | 8 ++++---- src/librustc_trans/trans/type_.rs | 4 ++-- src/librustc_trans/trans/type_of.rs | 2 +- src/librustc_typeck/check/mod.rs | 4 ++-- src/librustdoc/clean/mod.rs | 20 ++++++++++---------- src/libsyntax/ast.rs | 8 ++++---- src/libsyntax/ast_util.rs | 12 ++++++------ src/libsyntax/attr.rs | 8 +++++--- src/libsyntax/ext/build.rs | 4 ++-- src/libsyntax/ext/deriving/generic/mod.rs | 2 +- src/libsyntax/ext/quote.rs | 4 ++-- src/libsyntax/parse/mod.rs | 6 ++++-- src/test/run-fail/assert-as-macro.rs | 4 ++-- src/test/run-fail/panic.rs | 7 ++----- src/test/run-pass/tydesc-name.rs | 4 ++-- 22 files changed, 81 insertions(+), 78 deletions(-) diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 425e34cd9f042..64ca49d76f3c8 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -46,7 +46,7 @@ use syntax::ast_util::is_shift_binop; use syntax::attr::{self, AttrMetaMethods}; use syntax::codemap::{Span, DUMMY_SP}; use syntax::parse::token; -use syntax::ast::{TyI, TyU, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64}; +use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64}; use syntax::ast_util; use syntax::ptr::P; use syntax::visit::{self, Visitor}; @@ -216,7 +216,7 @@ impl LintPass for TypeLimits { match lit.node { ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => { - let int_type = if t == ast::TyI { + let int_type = if t == ast::TyIs { cx.sess().target.int_type } else { t }; let (min, max) = int_ty_range(int_type); @@ -233,7 +233,7 @@ impl LintPass for TypeLimits { }; }, ty::ty_uint(t) => { - let uint_type = if t == ast::TyU { + let uint_type = if t == ast::TyUs { cx.sess().target.uint_type } else { t }; let (min, max) = uint_ty_range(uint_type); @@ -296,7 +296,7 @@ impl LintPass for TypeLimits { // warnings are consistent between 32- and 64-bit platforms fn int_ty_range(int_ty: ast::IntTy) -> (i64, i64) { match int_ty { - ast::TyI => (i64::MIN, i64::MAX), + ast::TyIs=> (i64::MIN, i64::MAX), ast::TyI8 => (i8::MIN as i64, i8::MAX as i64), ast::TyI16 => (i16::MIN as i64, i16::MAX as i64), ast::TyI32 => (i32::MIN as i64, i32::MAX as i64), @@ -306,7 +306,7 @@ impl LintPass for TypeLimits { fn uint_ty_range(uint_ty: ast::UintTy) -> (u64, u64) { match uint_ty { - ast::TyU => (u64::MIN, u64::MAX), + ast::TyUs=> (u64::MIN, u64::MAX), ast::TyU8 => (u8::MIN as u64, u8::MAX as u64), ast::TyU16 => (u16::MIN as u64, u16::MAX as u64), ast::TyU32 => (u32::MIN as u64, u32::MAX as u64), @@ -323,7 +323,7 @@ impl LintPass for TypeLimits { fn int_ty_bits(int_ty: ast::IntTy, target_int_ty: ast::IntTy) -> u64 { match int_ty { - ast::TyI => int_ty_bits(target_int_ty, target_int_ty), + ast::TyIs=> int_ty_bits(target_int_ty, target_int_ty), ast::TyI8 => i8::BITS as u64, ast::TyI16 => i16::BITS as u64, ast::TyI32 => i32::BITS as u64, @@ -333,7 +333,7 @@ impl LintPass for TypeLimits { fn uint_ty_bits(uint_ty: ast::UintTy, target_uint_ty: ast::UintTy) -> u64 { match uint_ty { - ast::TyU => uint_ty_bits(target_uint_ty, target_uint_ty), + ast::TyUs=> uint_ty_bits(target_uint_ty, target_uint_ty), ast::TyU8 => u8::BITS as u64, ast::TyU16 => u16::BITS as u64, ast::TyU32 => u32::BITS as u64, @@ -404,14 +404,14 @@ struct ImproperCTypesVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { fn check_def(&mut self, sp: Span, ty_id: ast::NodeId, path_id: ast::NodeId) { match self.cx.tcx.def_map.borrow()[path_id].clone() { - def::DefPrimTy(ast::TyInt(ast::TyI)) => { + def::DefPrimTy(ast::TyInt(ast::TyIs)) => { self.cx.span_lint(IMPROPER_CTYPES, sp, - "found rust type `int` in foreign module, while \ + "found rust type `isize` in foreign module, while \ libc::c_int or libc::c_long should be used"); } - def::DefPrimTy(ast::TyUint(ast::TyU)) => { + def::DefPrimTy(ast::TyUint(ast::TyUs)) => { self.cx.span_lint(IMPROPER_CTYPES, sp, - "found rust type `uint` in foreign module, while \ + "found rust type `usize` in foreign module, while \ libc::c_uint or libc::c_ulong should be used"); } def::DefTy(..) => { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 07dc13ff0d48f..a39126f085164 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -443,8 +443,8 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w let tcx = st.tcx; match next(st) { 'b' => return tcx.types.bool, - 'i' => return tcx.types.int, - 'u' => return tcx.types.uint, + 'i' => { /* eat the s of is */ next(st); return tcx.types.int }, + 'u' => { /* eat the s of us */ next(st); return tcx.types.uint }, 'M' => { match next(st) { 'b' => return tcx.types.u8, diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 0042209aced6a..c019d129218b6 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -61,7 +61,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t ty::ty_char => mywrite!(w, "c"), ty::ty_int(t) => { match t { - ast::TyI => mywrite!(w, "i"), + ast::TyIs => mywrite!(w, "is"), ast::TyI8 => mywrite!(w, "MB"), ast::TyI16 => mywrite!(w, "MW"), ast::TyI32 => mywrite!(w, "ML"), @@ -70,7 +70,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t } ty::ty_uint(t) => { match t { - ast::TyU => mywrite!(w, "u"), + ast::TyUs => mywrite!(w, "us"), ast::TyU8 => mywrite!(w, "Mb"), ast::TyU16 => mywrite!(w, "Mw"), ast::TyU32 => mywrite!(w, "Ml"), diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 32482fce4daa8..1aec7252a3c1d 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -528,12 +528,12 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result (int, const_int, i64), + ty::ty_int(ast::TyIs) => (int, const_int, i64), ty::ty_int(ast::TyI8) => (i8, const_int, i64), ty::ty_int(ast::TyI16) => (i16, const_int, i64), ty::ty_int(ast::TyI32) => (i32, const_int, i64), ty::ty_int(ast::TyI64) => (i64, const_int, i64), - ty::ty_uint(ast::TyU) => (uint, const_uint, u64), + ty::ty_uint(ast::TyUs) => (uint, const_uint, u64), ty::ty_uint(ast::TyU8) => (u8, const_uint, u64), ty::ty_uint(ast::TyU16) => (u16, const_uint, u64), ty::ty_uint(ast::TyU32) => (u32, const_uint, u64), diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c359233eca173..62f1a2b49d444 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2302,12 +2302,12 @@ impl<'tcx> CommonTypes<'tcx> { bool: intern_ty(arena, interner, ty_bool), char: intern_ty(arena, interner, ty_char), err: intern_ty(arena, interner, ty_err), - int: intern_ty(arena, interner, ty_int(ast::TyI)), + int: intern_ty(arena, interner, ty_int(ast::TyIs)), i8: intern_ty(arena, interner, ty_int(ast::TyI8)), i16: intern_ty(arena, interner, ty_int(ast::TyI16)), i32: intern_ty(arena, interner, ty_int(ast::TyI32)), i64: intern_ty(arena, interner, ty_int(ast::TyI64)), - uint: intern_ty(arena, interner, ty_uint(ast::TyU)), + uint: intern_ty(arena, interner, ty_uint(ast::TyUs)), u8: intern_ty(arena, interner, ty_uint(ast::TyU8)), u16: intern_ty(arena, interner, ty_uint(ast::TyU16)), u32: intern_ty(arena, interner, ty_uint(ast::TyU32)), @@ -2653,7 +2653,7 @@ impl FlagComputation { pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> { match tm { - ast::TyI => tcx.types.int, + ast::TyIs => tcx.types.int, ast::TyI8 => tcx.types.i8, ast::TyI16 => tcx.types.i16, ast::TyI32 => tcx.types.i32, @@ -2663,7 +2663,7 @@ pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> { pub fn mk_mach_uint<'tcx>(tcx: &ctxt<'tcx>, tm: ast::UintTy) -> Ty<'tcx> { match tm { - ast::TyU => tcx.types.uint, + ast::TyUs => tcx.types.uint, ast::TyU8 => tcx.types.u8, ast::TyU16 => tcx.types.u16, ast::TyU32 => tcx.types.u32, @@ -3324,7 +3324,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { let result = match ty.sty { // uint and int are ffi-unsafe - ty_uint(ast::TyU) | ty_int(ast::TyI) => { + ty_uint(ast::TyUs) | ty_int(ast::TyIs) => { TC::ReachesFfiUnsafe } @@ -3896,7 +3896,7 @@ pub fn type_is_fresh(ty: Ty) -> bool { pub fn type_is_uint(ty: Ty) -> bool { match ty.sty { - ty_infer(IntVar(_)) | ty_uint(ast::TyU) => true, + ty_infer(IntVar(_)) | ty_uint(ast::TyUs) => true, _ => false } } @@ -3942,7 +3942,7 @@ pub fn type_is_signed(ty: Ty) -> bool { pub fn type_is_machine(ty: Ty) -> bool { match ty.sty { - ty_int(ast::TyI) | ty_uint(ast::TyU) => false, + ty_int(ast::TyIs) | ty_uint(ast::TyUs) => false, ty_int(..) | ty_uint(..) | ty_float(..) => true, _ => false } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 58102fe5629d9..cc9abecc20fc8 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -86,9 +86,9 @@ use syntax::ast::{PolyTraitRef, PrimTy, SelfExplicit}; use syntax::ast::{RegionTyParamBound, StructField}; use syntax::ast::{TraitRef, TraitTyParamBound}; use syntax::ast::{Ty, TyBool, TyChar, TyF32}; -use syntax::ast::{TyF64, TyFloat, TyI, TyI8, TyI16, TyI32, TyI64, TyInt, TyObjectSum}; +use syntax::ast::{TyF64, TyFloat, TyIs, TyI8, TyI16, TyI32, TyI64, TyInt, TyObjectSum}; use syntax::ast::{TyParam, TyParamBound, TyPath, TyPtr, TyPolyTraitRef, TyQPath}; -use syntax::ast::{TyRptr, TyStr, TyU, TyU8, TyU16, TyU32, TyU64, TyUint}; +use syntax::ast::{TyRptr, TyStr, TyUs, TyU8, TyU16, TyU32, TyU64, TyUint}; use syntax::ast::{TypeImplItem}; use syntax::ast; use syntax::ast_map; @@ -833,13 +833,15 @@ impl PrimitiveTypeTable { table.intern("char", TyChar); table.intern("f32", TyFloat(TyF32)); table.intern("f64", TyFloat(TyF64)); - table.intern("int", TyInt(TyI)); + table.intern("int", TyInt(TyIs)); + table.intern("isize", TyInt(TyIs)); table.intern("i8", TyInt(TyI8)); table.intern("i16", TyInt(TyI16)); table.intern("i32", TyInt(TyI32)); table.intern("i64", TyInt(TyI64)); table.intern("str", TyStr); - table.intern("uint", TyUint(TyU)); + table.intern("uint", TyUint(TyUs)); + table.intern("usize", TyUint(TyUs)); table.intern("u8", TyUint(TyU8)); table.intern("u16", TyUint(TyU16)); table.intern("u32", TyUint(TyU32)); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index edcfaae0f802d..b889b52207885 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -903,8 +903,8 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( ty::ty_int(t) => { let llty = Type::int_from_ty(cx.ccx(), t); let min = match t { - ast::TyI if llty == Type::i32(cx.ccx()) => i32::MIN as u64, - ast::TyI => i64::MIN as u64, + ast::TyIs if llty == Type::i32(cx.ccx()) => i32::MIN as u64, + ast::TyIs => i64::MIN as u64, ast::TyI8 => i8::MIN as u64, ast::TyI16 => i16::MIN as u64, ast::TyI32 => i32::MIN as u64, diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 3f0f7fd9bd303..c099c80f86334 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -1797,14 +1797,14 @@ fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_bool => ("bool".to_string(), DW_ATE_boolean), ty::ty_char => ("char".to_string(), DW_ATE_unsigned_char), ty::ty_int(int_ty) => match int_ty { - ast::TyI => ("int".to_string(), DW_ATE_signed), + ast::TyIs => ("isize".to_string(), DW_ATE_signed), ast::TyI8 => ("i8".to_string(), DW_ATE_signed), ast::TyI16 => ("i16".to_string(), DW_ATE_signed), ast::TyI32 => ("i32".to_string(), DW_ATE_signed), ast::TyI64 => ("i64".to_string(), DW_ATE_signed) }, ty::ty_uint(uint_ty) => match uint_ty { - ast::TyU => ("uint".to_string(), DW_ATE_unsigned), + ast::TyUs => ("usize".to_string(), DW_ATE_unsigned), ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned), ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned), ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned), @@ -3729,12 +3729,12 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_bool => output.push_str("bool"), ty::ty_char => output.push_str("char"), ty::ty_str => output.push_str("str"), - ty::ty_int(ast::TyI) => output.push_str("int"), + ty::ty_int(ast::TyIs) => output.push_str("isize"), ty::ty_int(ast::TyI8) => output.push_str("i8"), ty::ty_int(ast::TyI16) => output.push_str("i16"), ty::ty_int(ast::TyI32) => output.push_str("i32"), ty::ty_int(ast::TyI64) => output.push_str("i64"), - ty::ty_uint(ast::TyU) => output.push_str("uint"), + ty::ty_uint(ast::TyUs) => output.push_str("usize"), ty::ty_uint(ast::TyU8) => output.push_str("u8"), ty::ty_uint(ast::TyU16) => output.push_str("u16"), ty::ty_uint(ast::TyU32) => output.push_str("u32"), diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs index 3785c2fb9bc54..88199f97b54ba 100644 --- a/src/librustc_trans/trans/type_.rs +++ b/src/librustc_trans/trans/type_.rs @@ -112,7 +112,7 @@ impl Type { pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type { match t { - ast::TyI => ccx.int_type(), + ast::TyIs => ccx.int_type(), ast::TyI8 => Type::i8(ccx), ast::TyI16 => Type::i16(ccx), ast::TyI32 => Type::i32(ccx), @@ -122,7 +122,7 @@ impl Type { pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type { match t { - ast::TyU => ccx.int_type(), + ast::TyUs => ccx.int_type(), ast::TyU8 => Type::i8(ccx), ast::TyU16 => Type::i16(ccx), ast::TyU32 => Type::i32(ccx), diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 3e499ea8498fb..d2f33c03ed549 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -264,7 +264,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { } match unsized_part_of_type(cx.tcx(), t).sty { - ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyU), + ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyUs), ty::ty_trait(_) => Type::vtable_ptr(cx), _ => panic!("Unexpected type returned from unsized_part_of_type : {}", t.repr(cx.tcx())) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1b51434a58cc1..7be383f2a026d 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4859,7 +4859,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, ast::TyU16 => disr as u16 as Disr == disr, ast::TyU32 => disr as u32 as Disr == disr, ast::TyU64 => disr as u64 as Disr == disr, - ast::TyU => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr) + ast::TyUs => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr) } } fn int_in_range(ccx: &CrateCtxt, ty: ast::IntTy, disr: ty::Disr) -> bool { @@ -4868,7 +4868,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, ast::TyI16 => disr as i16 as Disr == disr, ast::TyI32 => disr as i32 as Disr == disr, ast::TyI64 => disr as i64 as Disr == disr, - ast::TyI => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr) + ast::TyIs => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr) } } match ty { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bb9a9ac430340..60faa09b964dd 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1238,8 +1238,8 @@ pub enum Type { #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy)] pub enum PrimitiveType { - Int, I8, I16, I32, I64, - Uint, U8, U16, U32, U64, + Isize, I8, I16, I32, I64, + Usize, U8, U16, U32, U64, F32, F64, Char, Bool, @@ -1264,12 +1264,12 @@ pub enum TypeKind { impl PrimitiveType { fn from_str(s: &str) -> Option { match s.as_slice() { - "int" => Some(Int), + "isize" | "int" => Some(Isize), "i8" => Some(I8), "i16" => Some(I16), "i32" => Some(I32), "i64" => Some(I64), - "uint" => Some(Uint), + "usize" | "uint" => Some(Usize), "u8" => Some(U8), "u16" => Some(U16), "u32" => Some(U32), @@ -1308,12 +1308,12 @@ impl PrimitiveType { pub fn to_string(&self) -> &'static str { match *self { - Int => "int", + Isize => "isize", I8 => "i8", I16 => "i16", I32 => "i32", I64 => "i64", - Uint => "uint", + Usize => "usize", U8 => "u8", U16 => "u16", U32 => "u32", @@ -1387,12 +1387,12 @@ impl<'tcx> Clean for ty::Ty<'tcx> { match self.sty { ty::ty_bool => Primitive(Bool), ty::ty_char => Primitive(Char), - ty::ty_int(ast::TyI) => Primitive(Int), + ty::ty_int(ast::TyIs) => Primitive(Isize), ty::ty_int(ast::TyI8) => Primitive(I8), ty::ty_int(ast::TyI16) => Primitive(I16), ty::ty_int(ast::TyI32) => Primitive(I32), ty::ty_int(ast::TyI64) => Primitive(I64), - ty::ty_uint(ast::TyU) => Primitive(Uint), + ty::ty_uint(ast::TyUs) => Primitive(Usize), ty::ty_uint(ast::TyU8) => Primitive(U8), ty::ty_uint(ast::TyU16) => Primitive(U16), ty::ty_uint(ast::TyU32) => Primitive(U32), @@ -2265,12 +2265,12 @@ fn resolve_type(cx: &DocContext, ast::TyStr => return Primitive(Str), ast::TyBool => return Primitive(Bool), ast::TyChar => return Primitive(Char), - ast::TyInt(ast::TyI) => return Primitive(Int), + ast::TyInt(ast::TyIs) => return Primitive(Isize), ast::TyInt(ast::TyI8) => return Primitive(I8), ast::TyInt(ast::TyI16) => return Primitive(I16), ast::TyInt(ast::TyI32) => return Primitive(I32), ast::TyInt(ast::TyI64) => return Primitive(I64), - ast::TyUint(ast::TyU) => return Primitive(Uint), + ast::TyUint(ast::TyUs) => return Primitive(Usize), ast::TyUint(ast::TyU8) => return Primitive(U8), ast::TyUint(ast::TyU16) => return Primitive(U16), ast::TyUint(ast::TyU32) => return Primitive(U32), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7aa7c4fcfb301..032ab05a418b2 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1087,7 +1087,7 @@ pub struct Typedef { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub enum IntTy { - TyI, + TyIs, TyI8, TyI16, TyI32, @@ -1103,7 +1103,7 @@ impl fmt::Show for IntTy { impl IntTy { pub fn suffix_len(&self) -> uint { match *self { - TyI => 1, + TyIs => 1, TyI8 => 2, TyI16 | TyI32 | TyI64 => 3, } @@ -1112,7 +1112,7 @@ impl IntTy { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub enum UintTy { - TyU, + TyUs, TyU8, TyU16, TyU32, @@ -1122,7 +1122,7 @@ pub enum UintTy { impl UintTy { pub fn suffix_len(&self) -> uint { match *self { - TyU => 1, + TyUs => 1, TyU8 => 2, TyU16 | TyU32 | TyU64 => 3, } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 5e03afec16cf8..d6df9f46621a7 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -120,8 +120,8 @@ pub fn is_path(e: P) -> bool { /// We want to avoid "45int" and "-3int" in favor of "45" and "-3" pub fn int_ty_to_string(t: IntTy, val: Option) -> String { let s = match t { - TyI if val.is_some() => "i", - TyI => "int", + TyIs if val.is_some() => "is", + TyIs => "isize", TyI8 => "i8", TyI16 => "i16", TyI32 => "i32", @@ -141,7 +141,7 @@ pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, - TyI | TyI32 => 0x80000000u64, // actually ni about TyI + TyIs | TyI32 => 0x80000000u64, // actually ni about TyIm TyI64 => 0x8000000000000000u64 } } @@ -150,8 +150,8 @@ pub fn int_ty_max(t: IntTy) -> u64 { /// We want to avoid "42uint" in favor of "42u" pub fn uint_ty_to_string(t: UintTy, val: Option) -> String { let s = match t { - TyU if val.is_some() => "u", - TyU => "uint", + TyUs if val.is_some() => "us", + TyUs => "usize", TyU8 => "u8", TyU16 => "u16", TyU32 => "u32", @@ -168,7 +168,7 @@ pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, - TyU | TyU32 => 0xffffffffu64, // actually ni about TyU + TyUs | TyU32 => 0xffffffffu64, // actually ni about TyUm TyU64 => 0xffffffffffffffffu64 } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 43e23f26e930e..523477eef22c8 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -457,8 +457,10 @@ fn int_type_of_word(s: &str) -> Option { "u32" => Some(UnsignedInt(ast::TyU32)), "i64" => Some(SignedInt(ast::TyI64)), "u64" => Some(UnsignedInt(ast::TyU64)), - "int" => Some(SignedInt(ast::TyI)), - "uint" => Some(UnsignedInt(ast::TyU)), + "int" => Some(SignedInt(ast::TyIs)), + "uint" => Some(UnsignedInt(ast::TyUs)), + "isize" => Some(SignedInt(ast::TyIs)), + "usize" => Some(UnsignedInt(ast::TyUs)), _ => None } } @@ -502,7 +504,7 @@ impl IntType { SignedInt(ast::TyI16) | UnsignedInt(ast::TyU16) | SignedInt(ast::TyI32) | UnsignedInt(ast::TyU32) | SignedInt(ast::TyI64) | UnsignedInt(ast::TyU64) => true, - SignedInt(ast::TyI) | UnsignedInt(ast::TyU) => false + SignedInt(ast::TyIs) | UnsignedInt(ast::TyUs) => false } } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index ea345f3a458f4..843172cee19b1 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -642,10 +642,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.expr(sp, ast::ExprLit(P(respan(sp, lit)))) } fn expr_uint(&self, span: Span, i: uint) -> P { - self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyU))) + self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs))) } fn expr_int(&self, sp: Span, i: int) -> P { - self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyI, ast::Sign::new(i)))) + self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs, ast::Sign::new(i)))) } fn expr_u8(&self, sp: Span, u: u8) -> P { self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 1aa430c4a0829..1112eaa789026 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -1031,7 +1031,7 @@ impl<'a> MethodDef<'a> { let arms: Vec = variants.iter().enumerate() .map(|(index, variant)| { let pat = variant_to_pat(cx, sp, type_ident, &**variant); - let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyU)); + let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs)); cx.arm(sp, vec![pat], cx.expr_lit(sp, lit)) }).collect(); diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index f1b52fa33c386..ccc15449834c1 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -273,13 +273,13 @@ pub mod rt { ); } - impl_to_source_int! { signed, int, TyI } + impl_to_source_int! { signed, int, TyIs } impl_to_source_int! { signed, i8, TyI8 } impl_to_source_int! { signed, i16, TyI16 } impl_to_source_int! { signed, i32, TyI32 } impl_to_source_int! { signed, i64, TyI64 } - impl_to_source_int! { unsigned, uint, TyU } + impl_to_source_int! { unsigned, uint, TyUs } impl_to_source_int! { unsigned, u8, TyU8 } impl_to_source_int! { unsigned, u16, TyU16 } impl_to_source_int! { unsigned, u32, TyU32 } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index b0969a573e66b..c26613b4d6cb3 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -701,12 +701,14 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> if let Some(suf) = suffix { if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")} ty = match suf { - "i" => ast::SignedIntLit(ast::TyI, ast::Plus), + "i" => ast::SignedIntLit(ast::TyIs, ast::Plus), + "is" => ast::SignedIntLit(ast::TyIs, ast::Plus), "i8" => ast::SignedIntLit(ast::TyI8, ast::Plus), "i16" => ast::SignedIntLit(ast::TyI16, ast::Plus), "i32" => ast::SignedIntLit(ast::TyI32, ast::Plus), "i64" => ast::SignedIntLit(ast::TyI64, ast::Plus), - "u" => ast::UnsignedIntLit(ast::TyU), + "u" => ast::UnsignedIntLit(ast::TyUs), + "us" => ast::UnsignedIntLit(ast::TyUs), "u8" => ast::UnsignedIntLit(ast::TyU8), "u16" => ast::UnsignedIntLit(ast::TyU16), "u32" => ast::UnsignedIntLit(ast::TyU32), diff --git a/src/test/run-fail/assert-as-macro.rs b/src/test/run-fail/assert-as-macro.rs index fb069e61bd2a1..59e79fe9266f0 100644 --- a/src/test/run-fail/assert-as-macro.rs +++ b/src/test/run-fail/assert-as-macro.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:assertion failed: 1i == 2 +// error-pattern:assertion failed: 1is == 2 fn main() { - assert!(1i == 2); + assert!(1is == 2); } diff --git a/src/test/run-fail/panic.rs b/src/test/run-fail/panic.rs index 54ccc98bcd924..dd4c58f176c84 100644 --- a/src/test/run-fail/panic.rs +++ b/src/test/run-fail/panic.rs @@ -8,8 +8,5 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - - - -// error-pattern:1i == 2 -fn main() { assert!((1i == 2)); } +// error-pattern:1is == 2 +fn main() { assert!((1is == 2)); } diff --git a/src/test/run-pass/tydesc-name.rs b/src/test/run-pass/tydesc-name.rs index 4f473755cb6cf..e3b148ac92db6 100644 --- a/src/test/run-pass/tydesc-name.rs +++ b/src/test/run-pass/tydesc-name.rs @@ -17,7 +17,7 @@ struct Foo { pub fn main() { unsafe { - assert_eq!((*get_tydesc::()).name, "int"); - assert_eq!((*get_tydesc::>()).name, "Foo"); + assert_eq!((*get_tydesc::()).name, "isize"); + assert_eq!((*get_tydesc::>()).name, "Foo"); } } From 503709708c72401dbe091ed5c7e0494efabe0669 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Tue, 6 Jan 2015 14:03:46 +1300 Subject: [PATCH 23/49] Change `std::kinds` to `std::markers`; flatten `std::kinds::marker` [breaking-change] --- src/doc/guide-unsafe.md | 4 +- src/liballoc/arc.rs | 2 +- src/liballoc/boxed.rs | 2 +- src/liballoc/rc.rs | 24 +- src/libcollections/btree/map.rs | 10 +- src/libcollections/lib.rs | 6 +- src/libcollections/ring_buf.rs | 6 +- src/libcollections/slice.rs | 2 +- src/libcollections/vec.rs | 2 +- src/libcore/array.rs | 2 +- src/libcore/atomic.rs | 2 +- src/libcore/borrow.rs | 2 +- src/libcore/cell.rs | 6 +- src/libcore/clone.rs | 2 +- src/libcore/cmp.rs | 4 +- src/libcore/fmt/mod.rs | 2 +- src/libcore/iter.rs | 2 +- src/libcore/kinds.rs | 298 ----------------- src/libcore/lib.rs | 6 +- src/libcore/markers.rs | 299 ++++++++++++++++++ src/libcore/mem.rs | 2 +- src/libcore/num/mod.rs | 4 +- src/libcore/ops.rs | 2 +- src/libcore/prelude.rs | 2 +- src/libcore/ptr.rs | 2 +- src/libcore/raw.rs | 2 +- src/libcore/slice.rs | 16 +- src/libcore/str/mod.rs | 2 +- src/libcore/ty.rs | 2 +- src/libcoretest/hash/mod.rs | 2 +- src/libcoretest/num/mod.rs | 2 +- src/libcoretest/option.rs | 4 +- src/liblibc/lib.rs | 4 +- src/librand/lib.rs | 4 +- src/librustc/middle/expr_use_visitor.rs | 4 +- src/librustc/middle/infer/unify.rs | 6 +- src/librustc_typeck/variance.rs | 4 +- src/libstd/collections/hash/map.rs | 2 +- src/libstd/collections/hash/set.rs | 2 +- src/libstd/collections/hash/table.rs | 22 +- src/libstd/hash.rs | 2 +- src/libstd/io/mod.rs | 2 +- src/libstd/io/stdio.rs | 2 +- src/libstd/lib.rs | 11 +- src/libstd/num/mod.rs | 2 +- src/libstd/os.rs | 2 +- src/libstd/path/mod.rs | 2 +- src/libstd/path/posix.rs | 2 +- src/libstd/prelude/v1.rs | 2 +- src/libstd/rand/os.rs | 2 +- src/libstd/rt/mod.rs | 2 +- src/libstd/sync/mpsc/blocking.rs | 4 +- src/libstd/sync/mpsc/mod.rs | 6 +- src/libstd/sync/mpsc/select.rs | 6 +- src/libstd/sync/mutex.rs | 6 +- src/libstd/sync/once.rs | 2 +- src/libstd/sync/rwlock.rs | 10 +- src/libstd/sys/common/mutex.rs | 2 +- src/libstd/sys/unix/c.rs | 8 +- src/libstd/sys/unix/mutex.rs | 2 +- src/libstd/thread.rs | 2 +- src/libstd/thread_local/mod.rs | 4 +- src/libstd/thread_local/scoped.rs | 10 +- src/libstd/thunk.rs | 2 +- src/libsyntax/ext/deriving/bounds.rs | 2 +- src/libunicode/tables.rs | 2 +- .../compile-fail/associated-types-unsized.rs | 2 +- .../compile-fail/bad-method-typaram-kind.rs | 2 +- src/test/compile-fail/bad-sized.rs | 6 +- .../borrowck-move-out-of-static-item.rs | 6 +- .../borrowck-struct-update-with-dtor.rs | 2 +- .../builtin-superkinds-double-superkind.rs | 4 +- .../builtin-superkinds-in-metadata.rs | 2 +- .../builtin-superkinds-typaram-not-send.rs | 2 +- .../check-static-values-constraints.rs | 2 +- .../compile-fail/comm-not-freeze-receiver.rs | 2 +- src/test/compile-fail/comm-not-freeze.rs | 2 +- src/test/compile-fail/dst-bad-assign-2.rs | 2 +- src/test/compile-fail/dst-bad-assign.rs | 2 +- src/test/compile-fail/dst-bad-deep.rs | 2 +- .../dst-object-from-unsized-type.rs | 8 +- .../compile-fail/dst-sized-trait-param.rs | 4 +- .../error-should-say-copy-not-pod.rs | 2 +- src/test/compile-fail/issue-14366.rs | 2 +- src/test/compile-fail/issue-15756.rs | 2 +- src/test/compile-fail/issue-16538.rs | 2 +- .../compile-fail/issue-17718-static-move.rs | 6 +- .../compile-fail/issue-17718-static-sync.rs | 8 +- src/test/compile-fail/issue-18107.rs | 2 +- src/test/compile-fail/issue-19883.rs | 6 +- src/test/compile-fail/issue-20005.rs | 4 +- src/test/compile-fail/issue-3907-2.rs | 2 +- src/test/compile-fail/issue-5035-2.rs | 2 +- src/test/compile-fail/issue-5543.rs | 2 +- src/test/compile-fail/issue-5883.rs | 4 +- src/test/compile-fail/issue-7013.rs | 4 +- src/test/compile-fail/issue-7364.rs | 4 +- src/test/compile-fail/kindck-copy.rs | 22 +- .../compile-fail/kindck-impl-type-params-2.rs | 2 +- .../compile-fail/kindck-impl-type-params.rs | 12 +- .../kindck-inherited-copy-bound.rs | 4 +- src/test/compile-fail/kindck-nonsendable-1.rs | 4 +- src/test/compile-fail/kindck-send-object.rs | 4 +- src/test/compile-fail/kindck-send-object1.rs | 4 +- src/test/compile-fail/kindck-send-object2.rs | 4 +- src/test/compile-fail/kindck-send-unsafe.rs | 2 +- src/test/compile-fail/lint-dead-code-4.rs | 4 +- src/test/compile-fail/marker-no-copy.rs | 4 +- src/test/compile-fail/marker-no-send.rs | 4 +- src/test/compile-fail/marker-no-share.rs | 4 +- src/test/compile-fail/mut-not-freeze.rs | 4 +- .../compile-fail/mutable-enum-indirect.rs | 8 +- src/test/compile-fail/no-send-res-ports.rs | 4 +- src/test/compile-fail/no_send-enum.rs | 8 +- src/test/compile-fail/no_send-rc.rs | 4 +- src/test/compile-fail/no_send-struct.rs | 8 +- src/test/compile-fail/no_share-enum.rs | 8 +- src/test/compile-fail/no_share-rc.rs | 4 +- src/test/compile-fail/no_share-struct.rs | 8 +- src/test/compile-fail/opt-out-copy-bad.rs | 2 +- src/test/compile-fail/range-1.rs | 2 +- ...egions-infer-contravariance-due-to-decl.rs | 4 +- .../regions-infer-covariance-due-to-decl.rs | 4 +- .../regions-infer-invariance-due-to-decl.rs | 4 +- .../compile-fail/repeat-to-run-dtor-twice.rs | 2 +- .../compile-fail/static-items-cant-move.rs | 6 +- .../syntax-trait-polarity-feature-gate.rs | 2 +- .../compile-fail/syntax-trait-polarity.rs | 2 +- .../compile-fail/task-rng-isnt-sendable.rs | 4 +- .../trait-bounds-not-on-bare-trait.rs | 2 +- .../typeck-unsafe-always-share.rs | 16 +- .../unboxed-closure-sugar-region.rs | 2 +- src/test/compile-fail/unique-unique-kind.rs | 4 +- src/test/compile-fail/unsendable-class.rs | 4 +- src/test/compile-fail/unsized-bare-typaram.rs | 2 +- src/test/compile-fail/unsized-enum.rs | 4 +- src/test/compile-fail/unsized-struct.rs | 4 +- .../unsized-trait-impl-trait-arg.rs | 2 +- src/test/compile-fail/unsized3.rs | 12 +- src/test/compile-fail/unsized5.rs | 14 +- src/test/compile-fail/unsized6.rs | 28 +- src/test/compile-fail/unsized7.rs | 2 +- ...constraints-are-local-for-inherent-impl.rs | 2 +- ...se-constraints-are-local-for-trait-impl.rs | 2 +- .../associated-types-impl-redirect.rs | 2 +- ...iated-types-where-clause-impl-ambiguity.rs | 2 +- src/test/run-pass/const-block.rs | 2 +- src/test/run-pass/fsu-moves-and-copies.rs | 2 +- src/test/run-pass/hrtb-opt-in-copy.rs | 4 +- .../issue-17718-static-unsafe-interior.rs | 2 +- src/test/run-pass/issue-2718.rs | 2 +- .../run-pass/method-recursive-blanket-impl.rs | 2 +- src/test/run-pass/regions-infer-bivariance.rs | 2 +- src/test/run-pass/syntax-trait-polarity.rs | 2 +- 154 files changed, 635 insertions(+), 623 deletions(-) delete mode 100644 src/libcore/kinds.rs create mode 100644 src/libcore/markers.rs diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md index bda1b34563208..11bc0bc30f20e 100644 --- a/src/doc/guide-unsafe.md +++ b/src/doc/guide-unsafe.md @@ -703,10 +703,10 @@ Other features provided by lang items include: `deref`, and `add` respectively. - stack unwinding and general failure; the `eh_personality`, `fail` and `fail_bounds_checks` lang items. -- the traits in `std::kinds` used to indicate types that satisfy +- the traits in `std::markers` used to indicate types of various kinds; lang items `send`, `sync` and `copy`. - the marker types and variance indicators found in - `std::kinds::markers`; lang items `covariant_type`, + `std::markers`; lang items `covariant_type`, `contravariant_lifetime`, `no_sync_bound`, etc. Lang items are loaded lazily by the compiler; e.g. if one never uses diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 25f80ad11bd11..a3b77ccb6dbda 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -74,7 +74,7 @@ use core::clone::Clone; use core::fmt::{self, Show}; use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering}; use core::default::Default; -use core::kinds::{Sync, Send}; +use core::markers::{Sync, Send}; use core::mem::{min_align_of, size_of, drop}; use core::mem; use core::nonzero::NonZero; diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 6df8bb5f7aaf4..0b211c7c21256 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -18,7 +18,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; use core::hash::{self, Hash}; -use core::kinds::Sized; +use core::markers::Sized; use core::mem; use core::option::Option; use core::ptr::Unique; diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 175bba4e71dc4..c6eaaaeecca1b 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -148,7 +148,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; use core::hash::{self, Hash}; -use core::kinds::marker; +use core::markers; use core::mem::{transmute, min_align_of, size_of, forget}; use core::nonzero::NonZero; use core::ops::{Deref, Drop}; @@ -175,8 +175,8 @@ pub struct Rc { // FIXME #12808: strange names to try to avoid interfering with field accesses of the contained // type via Deref _ptr: NonZero<*mut RcBox>, - _nosend: marker::NoSend, - _noshare: marker::NoSync + _nosend: markers::NoSend, + _noshare: markers::NoSync } impl Rc { @@ -201,8 +201,8 @@ impl Rc { strong: Cell::new(1), weak: Cell::new(1) })), - _nosend: marker::NoSend, - _noshare: marker::NoSync + _nosend: markers::NoSend, + _noshare: markers::NoSync } } } @@ -223,8 +223,8 @@ impl Rc { self.inc_weak(); Weak { _ptr: self._ptr, - _nosend: marker::NoSend, - _noshare: marker::NoSync + _nosend: markers::NoSend, + _noshare: markers::NoSync } } } @@ -431,7 +431,7 @@ impl Clone for Rc { #[inline] fn clone(&self) -> Rc { self.inc_strong(); - Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync } + Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync } } } @@ -622,8 +622,8 @@ pub struct Weak { // FIXME #12808: strange names to try to avoid interfering with // field accesses of the contained type via Deref _ptr: NonZero<*mut RcBox>, - _nosend: marker::NoSend, - _noshare: marker::NoSync + _nosend: markers::NoSend, + _noshare: markers::NoSync } #[experimental = "Weak pointers may not belong in this module."] @@ -650,7 +650,7 @@ impl Weak { None } else { self.inc_strong(); - Some(Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync }) + Some(Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync }) } } } @@ -717,7 +717,7 @@ impl Clone for Weak { #[inline] fn clone(&self) -> Weak { self.inc_weak(); - Weak { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync } + Weak { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync } } } diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index b85ea65f5ce58..73cc46091e99a 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -480,7 +480,7 @@ enum Continuation { /// boilerplate gets cut out. mod stack { use core::prelude::*; - use core::kinds::marker; + use core::markers; use core::mem; use core::ops::{Deref, DerefMut}; use super::BTreeMap; @@ -494,7 +494,7 @@ mod stack { /// where `&'static` can be used in any function expecting any lifetime reference. pub struct IdRef<'id, T: 'id> { inner: &'id mut T, - marker: marker::InvariantLifetime<'id> + marker: markers::InvariantLifetime<'id> } impl<'id, T> Deref for IdRef<'id, T> { @@ -536,7 +536,7 @@ mod stack { pub struct Pusher<'id, 'a, K:'a, V:'a> { map: &'a mut BTreeMap, stack: Stack, - marker: marker::InvariantLifetime<'id> + marker: markers::InvariantLifetime<'id> } impl<'a, K, V> PartialSearchStack<'a, K, V> { @@ -571,11 +571,11 @@ mod stack { let pusher = Pusher { map: self.map, stack: self.stack, - marker: marker::InvariantLifetime + marker: markers::InvariantLifetime }; let node = IdRef { inner: unsafe { &mut *self.next }, - marker: marker::InvariantLifetime + marker: markers::InvariantLifetime }; closure(pusher, node) diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 5bf5f78af94c2..cbe5d2404e730 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -123,7 +123,9 @@ mod std { pub use core::option; // necessary for panic!() pub use core::clone; // deriving(Clone) pub use core::cmp; // deriving(Eq, Ord, etc.) - pub use core::kinds; // deriving(Copy) + #[cfg(stage0)] + pub use core::markers as kinds; + pub use core::markers; // deriving(Copy) pub use core::hash; // deriving(Hash) } @@ -138,7 +140,7 @@ mod prelude { pub use core::iter::{FromIterator, Extend, IteratorExt}; pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator}; pub use core::iter::{ExactSizeIterator}; - pub use core::kinds::{Copy, Send, Sized, Sync}; + pub use core::markers::{Copy, Send, Sized, Sync}; pub use core::mem::drop; pub use core::ops::{Drop, Fn, FnMut, FnOnce}; pub use core::option::Option; diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 11775f62b1c54..3c1cd101e3b86 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -20,7 +20,7 @@ use core::cmp::Ordering; use core::default::Default; use core::fmt; use core::iter::{self, repeat, FromIterator, RandomAccessIterator}; -use core::kinds::marker; +use core::markers; use core::mem; use core::num::{Int, UnsignedInt}; use core::ops::{Index, IndexMut}; @@ -534,7 +534,7 @@ impl RingBuf { head: self.head, cap: self.cap, ptr: self.ptr, - marker: marker::ContravariantLifetime::<'a>, + marker: markers::ContravariantLifetime::<'a>, } } @@ -1414,7 +1414,7 @@ pub struct IterMut<'a, T:'a> { tail: uint, head: uint, cap: uint, - marker: marker::ContravariantLifetime<'a>, + marker: markers::ContravariantLifetime<'a>, } #[stable] diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 9e5aa7d645ba0..d7e0b3d93532d 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -95,7 +95,7 @@ use core::cmp::Ordering::{self, Greater, Less}; use core::cmp::{self, Ord, PartialEq}; use core::iter::{Iterator, IteratorExt}; use core::iter::{range, range_step, MultiplicativeIterator}; -use core::kinds::Sized; +use core::markers::Sized; use core::mem::size_of; use core::mem; use core::ops::{FnMut, SliceMut}; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 99231e7253c3c..b3b560a23bdeb 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -55,7 +55,7 @@ use core::default::Default; use core::fmt; use core::hash::{self, Hash}; use core::iter::{repeat, FromIterator}; -use core::kinds::marker::{ContravariantLifetime, InvariantType}; +use core::markers::{ContravariantLifetime, InvariantType}; use core::mem; use core::nonzero::NonZero; use core::num::{Int, UnsignedInt}; diff --git a/src/libcore/array.rs b/src/libcore/array.rs index ba7714ad9bc8c..f85b17fb7f09b 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -17,7 +17,7 @@ use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use fmt; -use kinds::Copy; +use markers::Copy; use ops::Deref; use option::Option; diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 15c20253c8bc7..9e5bda4bf43c8 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -72,7 +72,7 @@ use self::Ordering::*; -use kinds::Sync; +use markers::Sync; use intrinsics; use cell::UnsafeCell; diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs index 2c08b97635580..c4adf724b2f71 100644 --- a/src/libcore/borrow.rs +++ b/src/libcore/borrow.rs @@ -47,7 +47,7 @@ use clone::Clone; use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd}; use fmt; -use kinds::Sized; +use markers::Sized; use ops::Deref; use option::Option; use self::Cow::*; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index fd18d6ac3f3b4..ae590b1de061b 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -161,7 +161,7 @@ use clone::Clone; use cmp::PartialEq; use default::Default; use fmt; -use kinds::{Copy, Send}; +use markers::{Copy, Send}; use ops::{Deref, DerefMut, Drop}; use option::Option; use option::Option::{None, Some}; @@ -520,11 +520,11 @@ impl<'b, T> DerefMut for RefMut<'b, T> { /// /// ```rust /// use std::cell::UnsafeCell; -/// use std::kinds::marker; +/// use std::markers; /// /// struct NotThreadSafe { /// value: UnsafeCell, -/// marker: marker::NoSync +/// marker: markers::NoSync /// } /// ``` /// diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 17991659f9789..78a5848f34dd6 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -21,7 +21,7 @@ #![stable] -use kinds::Sized; +use markers::Sized; /// A common trait for cloning an object. #[stable] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index af5e98ed30324..01f1073a5d390 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -43,7 +43,7 @@ use self::Ordering::*; -use kinds::Sized; +use markers::Sized; use option::Option::{self, Some, None}; /// Trait for equality comparisons which are [partial equivalence relations]( @@ -316,7 +316,7 @@ pub fn partial_max(v1: T, v2: T) -> Option { mod impls { use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering}; use cmp::Ordering::{Less, Greater, Equal}; - use kinds::Sized; + use markers::Sized; use option::Option; use option::Option::{Some, None}; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 951f5c29f00e8..ed01cf6476973 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -15,7 +15,7 @@ use any; use cell::{Cell, Ref, RefMut}; use iter::{Iterator, IteratorExt, range}; -use kinds::{Copy, Sized}; +use markers::{Copy, Sized}; use mem; use option::Option; use option::Option::{Some, None}; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index e5753f6cc2e78..ac5804c910d09 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -67,7 +67,7 @@ use num::{ToPrimitive, Int}; use ops::{Add, Deref, FnMut}; use option::Option; use option::Option::{Some, None}; -use std::kinds::Sized; +use std::markers::Sized; use uint; /// An interface for dealing with "external iterators". These types of iterators diff --git a/src/libcore/kinds.rs b/src/libcore/kinds.rs deleted file mode 100644 index 5d69938fccff7..0000000000000 --- a/src/libcore/kinds.rs +++ /dev/null @@ -1,298 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Primitive traits representing basic 'kinds' of types -//! -//! Rust types can be classified in various useful ways according to -//! intrinsic properties of the type. These classifications, often called -//! 'kinds', are represented as traits. -//! -//! They cannot be implemented by user code, but are instead implemented -//! by the compiler automatically for the types to which they apply. - -/// Types able to be transferred across task boundaries. -#[lang="send"] -pub unsafe trait Send : 'static { - // empty. -} - -/// Types with a constant size known at compile-time. -#[lang="sized"] -pub trait Sized { - // Empty. -} - -/// Types that can be copied by simply copying bits (i.e. `memcpy`). -#[lang="copy"] -pub trait Copy { - // Empty. -} - -/// Types that can be safely shared between tasks when aliased. -/// -/// The precise definition is: a type `T` is `Sync` if `&T` is -/// thread-safe. In other words, there is no possibility of data races -/// when passing `&T` references between tasks. -/// -/// As one would expect, primitive types like `u8` and `f64` are all -/// `Sync`, and so are simple aggregate types containing them (like -/// tuples, structs and enums). More instances of basic `Sync` types -/// include "immutable" types like `&T` and those with simple -/// inherited mutability, such as `Box`, `Vec` and most other -/// collection types. (Generic parameters need to be `Sync` for their -/// container to be `Sync`.) -/// -/// A somewhat surprising consequence of the definition is `&mut T` is -/// `Sync` (if `T` is `Sync`) even though it seems that it might -/// provide unsynchronised mutation. The trick is a mutable reference -/// stored in an aliasable reference (that is, `& &mut T`) becomes -/// read-only, as if it were a `& &T`, hence there is no risk of a data -/// race. -/// -/// Types that are not `Sync` are those that have "interior -/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell` -/// in `std::cell`. These types allow for mutation of their contents -/// even when in an immutable, aliasable slot, e.g. the contents of -/// `&Cell` can be `.set`, and do not ensure data races are -/// impossible, hence they cannot be `Sync`. A higher level example -/// of a non-`Sync` type is the reference counted pointer -/// `std::rc::Rc`, because any reference `&Rc` can clone a new -/// reference, which modifies the reference counts in a non-atomic -/// way. -/// -/// For cases when one does need thread-safe interior mutability, -/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in -/// the `sync` crate do ensure that any mutation cannot cause data -/// races. Hence these types are `Sync`. -/// -/// Users writing their own types with interior mutability (or anything -/// else that is not thread-safe) should use the `NoSync` marker type -/// (from `std::kinds::marker`) to ensure that the compiler doesn't -/// consider the user-defined type to be `Sync`. Any types with -/// interior mutability must also use the `std::cell::UnsafeCell` wrapper -/// around the value(s) which can be mutated when behind a `&` -/// reference; not doing this is undefined behaviour (for example, -/// `transmute`-ing from `&T` to `&mut T` is illegal). -#[lang="sync"] -pub unsafe trait Sync { - // Empty -} - -/// Marker types are special types that are used with unsafe code to -/// inform the compiler of special constraints. Marker types should -/// only be needed when you are creating an abstraction that is -/// implemented using unsafe code. In that case, you may want to embed -/// some of the marker types below into your type. -pub mod marker { - use super::{Copy,Sized}; - use clone::Clone; - - /// A marker type whose type parameter `T` is considered to be - /// covariant with respect to the type itself. This is (typically) - /// used to indicate that an instance of the type `T` is being stored - /// into memory and read from, even though that may not be apparent. - /// - /// For more information about variance, refer to this Wikipedia - /// article . - /// - /// *Note:* It is very unusual to have to add a covariant constraint. - /// If you are not sure, you probably want to use `InvariantType`. - /// - /// # Example - /// - /// Given a struct `S` that includes a type parameter `T` - /// but does not actually *reference* that type parameter: - /// - /// ```ignore - /// use std::mem; - /// - /// struct S { x: *() } - /// fn get(s: &S) -> T { - /// unsafe { - /// let x: *T = mem::transmute(s.x); - /// *x - /// } - /// } - /// ``` - /// - /// The type system would currently infer that the value of - /// the type parameter `T` is irrelevant, and hence a `S` is - /// a subtype of `S>` (or, for that matter, `S` for - /// any `U`). But this is incorrect because `get()` converts the - /// `*()` into a `*T` and reads from it. Therefore, we should include the - /// a marker field `CovariantType` to inform the type checker that - /// `S` is a subtype of `S` if `T` is a subtype of `U` - /// (for example, `S<&'static int>` is a subtype of `S<&'a int>` - /// for some lifetime `'a`, but not the other way around). - #[lang="covariant_type"] - #[derive(PartialEq, Eq, PartialOrd, Ord)] - pub struct CovariantType; - - impl Copy for CovariantType {} - impl Clone for CovariantType { - fn clone(&self) -> CovariantType { *self } - } - - /// A marker type whose type parameter `T` is considered to be - /// contravariant with respect to the type itself. This is (typically) - /// used to indicate that an instance of the type `T` will be consumed - /// (but not read from), even though that may not be apparent. - /// - /// For more information about variance, refer to this Wikipedia - /// article . - /// - /// *Note:* It is very unusual to have to add a contravariant constraint. - /// If you are not sure, you probably want to use `InvariantType`. - /// - /// # Example - /// - /// Given a struct `S` that includes a type parameter `T` - /// but does not actually *reference* that type parameter: - /// - /// ``` - /// use std::mem; - /// - /// struct S { x: *const () } - /// fn get(s: &S, v: T) { - /// unsafe { - /// let x: fn(T) = mem::transmute(s.x); - /// x(v) - /// } - /// } - /// ``` - /// - /// The type system would currently infer that the value of - /// the type parameter `T` is irrelevant, and hence a `S` is - /// a subtype of `S>` (or, for that matter, `S` for - /// any `U`). But this is incorrect because `get()` converts the - /// `*()` into a `fn(T)` and then passes a value of type `T` to it. - /// - /// Supplying a `ContravariantType` marker would correct the - /// problem, because it would mark `S` so that `S` is only a - /// subtype of `S` if `U` is a subtype of `T`; given that the - /// function requires arguments of type `T`, it must also accept - /// arguments of type `U`, hence such a conversion is safe. - #[lang="contravariant_type"] - #[derive(PartialEq, Eq, PartialOrd, Ord)] - pub struct ContravariantType; - - impl Copy for ContravariantType {} - impl Clone for ContravariantType { - fn clone(&self) -> ContravariantType { *self } - } - - /// A marker type whose type parameter `T` is considered to be - /// invariant with respect to the type itself. This is (typically) - /// used to indicate that instances of the type `T` may be read or - /// written, even though that may not be apparent. - /// - /// For more information about variance, refer to this Wikipedia - /// article . - /// - /// # Example - /// - /// The Cell type is an example which uses unsafe code to achieve - /// "interior" mutability: - /// - /// ``` - /// pub struct Cell { value: T } - /// # fn main() {} - /// ``` - /// - /// The type system would infer that `value` is only read here and - /// never written, but in fact `Cell` uses unsafe code to achieve - /// interior mutability. - #[lang="invariant_type"] - #[derive(PartialEq, Eq, PartialOrd, Ord)] - pub struct InvariantType; - - impl Copy for InvariantType {} - impl Clone for InvariantType { - fn clone(&self) -> InvariantType { *self } - } - - /// As `CovariantType`, but for lifetime parameters. Using - /// `CovariantLifetime<'a>` indicates that it is ok to substitute - /// a *longer* lifetime for `'a` than the one you originally - /// started with (e.g., you could convert any lifetime `'foo` to - /// `'static`). You almost certainly want `ContravariantLifetime` - /// instead, or possibly `InvariantLifetime`. The only case where - /// it would be appropriate is that you have a (type-casted, and - /// hence hidden from the type system) function pointer with a - /// signature like `fn(&'a T)` (and no other uses of `'a`). In - /// this case, it is ok to substitute a larger lifetime for `'a` - /// (e.g., `fn(&'static T)`), because the function is only - /// becoming more selective in terms of what it accepts as - /// argument. - /// - /// For more information about variance, refer to this Wikipedia - /// article . - #[lang="covariant_lifetime"] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct CovariantLifetime<'a>; - - /// As `ContravariantType`, but for lifetime parameters. Using - /// `ContravariantLifetime<'a>` indicates that it is ok to - /// substitute a *shorter* lifetime for `'a` than the one you - /// originally started with (e.g., you could convert `'static` to - /// any lifetime `'foo`). This is appropriate for cases where you - /// have an unsafe pointer that is actually a pointer into some - /// memory with lifetime `'a`, and thus you want to limit the - /// lifetime of your data structure to `'a`. An example of where - /// this is used is the iterator for vectors. - /// - /// For more information about variance, refer to this Wikipedia - /// article . - #[lang="contravariant_lifetime"] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct ContravariantLifetime<'a>; - - /// As `InvariantType`, but for lifetime parameters. Using - /// `InvariantLifetime<'a>` indicates that it is not ok to - /// substitute any other lifetime for `'a` besides its original - /// value. This is appropriate for cases where you have an unsafe - /// pointer that is actually a pointer into memory with lifetime `'a`, - /// and this pointer is itself stored in an inherently mutable - /// location (such as a `Cell`). - #[lang="invariant_lifetime"] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct InvariantLifetime<'a>; - - /// A type which is considered "not sendable", meaning that it cannot - /// be safely sent between tasks, even if it is owned. This is - /// typically embedded in other types, such as `Gc`, to ensure that - /// their instances remain thread-local. - #[lang="no_send_bound"] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct NoSend; - - /// A type which is considered "not POD", meaning that it is not - /// implicitly copyable. This is typically embedded in other types to - /// ensure that they are never copied, even if they lack a destructor. - #[lang="no_copy_bound"] - #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] - #[allow(missing_copy_implementations)] - pub struct NoCopy; - - /// A type which is considered "not sync", meaning that - /// its contents are not threadsafe, hence they cannot be - /// shared between tasks. - #[lang="no_sync_bound"] - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] - pub struct NoSync; - - /// A type which is considered managed by the GC. This is typically - /// embedded in other types. - #[lang="managed_bound"] - #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] - #[allow(missing_copy_implementations)] - pub struct Managed; -} - diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index aff0065c52744..c06dc056d20cb 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -111,7 +111,7 @@ pub mod ptr; /* Core language traits */ -pub mod kinds; +pub mod markers; pub mod ops; pub mod cmp; pub mod clone; @@ -150,7 +150,9 @@ mod core { mod std { pub use clone; pub use cmp; - pub use kinds; + #[cfg(stage0)] + pub use markers as kinds; + pub use markers; pub use option; pub use fmt; pub use hash; diff --git a/src/libcore/markers.rs b/src/libcore/markers.rs new file mode 100644 index 0000000000000..0663ceb68e69b --- /dev/null +++ b/src/libcore/markers.rs @@ -0,0 +1,299 @@ +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Primitive traits and marker types representing basic 'kinds' of types. +//! +//! Rust types can be classified in various useful ways according to +//! intrinsic properties of the type. These classifications, often called +//! 'kinds', are represented as traits. +//! +//! They cannot be implemented by user code, but are instead implemented +//! by the compiler automatically for the types to which they apply. +//! +//! Marker types are special types that are used with unsafe code to +//! inform the compiler of special constraints. Marker types should +//! only be needed when you are creating an abstraction that is +//! implemented using unsafe code. In that case, you may want to embed +//! some of the marker types below into your type. + + + +use clone::Clone; + + +/// Types able to be transferred across task boundaries. +#[lang="send"] +pub unsafe trait Send: 'static { + // empty. +} + +/// Types with a constant size known at compile-time. +#[lang="sized"] +pub trait Sized { + // Empty. +} + +/// Types that can be copied by simply copying bits (i.e. `memcpy`). +#[lang="copy"] +pub trait Copy { + // Empty. +} + +/// Types that can be safely shared between tasks when aliased. +/// +/// The precise definition is: a type `T` is `Sync` if `&T` is +/// thread-safe. In other words, there is no possibility of data races +/// when passing `&T` references between tasks. +/// +/// As one would expect, primitive types like `u8` and `f64` are all +/// `Sync`, and so are simple aggregate types containing them (like +/// tuples, structs and enums). More instances of basic `Sync` types +/// include "immutable" types like `&T` and those with simple +/// inherited mutability, such as `Box`, `Vec` and most other +/// collection types. (Generic parameters need to be `Sync` for their +/// container to be `Sync`.) +/// +/// A somewhat surprising consequence of the definition is `&mut T` is +/// `Sync` (if `T` is `Sync`) even though it seems that it might +/// provide unsynchronised mutation. The trick is a mutable reference +/// stored in an aliasable reference (that is, `& &mut T`) becomes +/// read-only, as if it were a `& &T`, hence there is no risk of a data +/// race. +/// +/// Types that are not `Sync` are those that have "interior +/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell` +/// in `std::cell`. These types allow for mutation of their contents +/// even when in an immutable, aliasable slot, e.g. the contents of +/// `&Cell` can be `.set`, and do not ensure data races are +/// impossible, hence they cannot be `Sync`. A higher level example +/// of a non-`Sync` type is the reference counted pointer +/// `std::rc::Rc`, because any reference `&Rc` can clone a new +/// reference, which modifies the reference counts in a non-atomic +/// way. +/// +/// For cases when one does need thread-safe interior mutability, +/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in +/// the `sync` crate do ensure that any mutation cannot cause data +/// races. Hence these types are `Sync`. +/// +/// Users writing their own types with interior mutability (or anything +/// else that is not thread-safe) should use the `NoSync` marker type +/// (from `std::markers`) to ensure that the compiler doesn't +/// consider the user-defined type to be `Sync`. Any types with +/// interior mutability must also use the `std::cell::UnsafeCell` wrapper +/// around the value(s) which can be mutated when behind a `&` +/// reference; not doing this is undefined behaviour (for example, +/// `transmute`-ing from `&T` to `&mut T` is illegal). +#[lang="sync"] +pub unsafe trait Sync { + // Empty +} + + +/// A marker type whose type parameter `T` is considered to be +/// covariant with respect to the type itself. This is (typically) +/// used to indicate that an instance of the type `T` is being stored +/// into memory and read from, even though that may not be apparent. +/// +/// For more information about variance, refer to this Wikipedia +/// article . +/// +/// *Note:* It is very unusual to have to add a covariant constraint. +/// If you are not sure, you probably want to use `InvariantType`. +/// +/// # Example +/// +/// Given a struct `S` that includes a type parameter `T` +/// but does not actually *reference* that type parameter: +/// +/// ```ignore +/// use std::mem; +/// +/// struct S { x: *() } +/// fn get(s: &S) -> T { +/// unsafe { +/// let x: *T = mem::transmute(s.x); +/// *x +/// } +/// } +/// ``` +/// +/// The type system would currently infer that the value of +/// the type parameter `T` is irrelevant, and hence a `S` is +/// a subtype of `S>` (or, for that matter, `S` for +/// any `U`). But this is incorrect because `get()` converts the +/// `*()` into a `*T` and reads from it. Therefore, we should include the +/// a marker field `CovariantType` to inform the type checker that +/// `S` is a subtype of `S` if `T` is a subtype of `U` +/// (for example, `S<&'static int>` is a subtype of `S<&'a int>` +/// for some lifetime `'a`, but not the other way around). +#[lang="covariant_type"] +#[derive(PartialEq, Eq, PartialOrd, Ord)] +pub struct CovariantType; + +impl Copy for CovariantType {} +impl Clone for CovariantType { + fn clone(&self) -> CovariantType { *self } +} + +/// A marker type whose type parameter `T` is considered to be +/// contravariant with respect to the type itself. This is (typically) +/// used to indicate that an instance of the type `T` will be consumed +/// (but not read from), even though that may not be apparent. +/// +/// For more information about variance, refer to this Wikipedia +/// article . +/// +/// *Note:* It is very unusual to have to add a contravariant constraint. +/// If you are not sure, you probably want to use `InvariantType`. +/// +/// # Example +/// +/// Given a struct `S` that includes a type parameter `T` +/// but does not actually *reference* that type parameter: +/// +/// ``` +/// use std::mem; +/// +/// struct S { x: *const () } +/// fn get(s: &S, v: T) { +/// unsafe { +/// let x: fn(T) = mem::transmute(s.x); +/// x(v) +/// } +/// } +/// ``` +/// +/// The type system would currently infer that the value of +/// the type parameter `T` is irrelevant, and hence a `S` is +/// a subtype of `S>` (or, for that matter, `S` for +/// any `U`). But this is incorrect because `get()` converts the +/// `*()` into a `fn(T)` and then passes a value of type `T` to it. +/// +/// Supplying a `ContravariantType` marker would correct the +/// problem, because it would mark `S` so that `S` is only a +/// subtype of `S` if `U` is a subtype of `T`; given that the +/// function requires arguments of type `T`, it must also accept +/// arguments of type `U`, hence such a conversion is safe. +#[lang="contravariant_type"] +#[derive(PartialEq, Eq, PartialOrd, Ord)] +pub struct ContravariantType; + +impl Copy for ContravariantType {} +impl Clone for ContravariantType { + fn clone(&self) -> ContravariantType { *self } +} + +/// A marker type whose type parameter `T` is considered to be +/// invariant with respect to the type itself. This is (typically) +/// used to indicate that instances of the type `T` may be read or +/// written, even though that may not be apparent. +/// +/// For more information about variance, refer to this Wikipedia +/// article . +/// +/// # Example +/// +/// The Cell type is an example which uses unsafe code to achieve +/// "interior" mutability: +/// +/// ``` +/// pub struct Cell { value: T } +/// # fn main() {} +/// ``` +/// +/// The type system would infer that `value` is only read here and +/// never written, but in fact `Cell` uses unsafe code to achieve +/// interior mutability. +#[lang="invariant_type"] +#[derive(PartialEq, Eq, PartialOrd, Ord)] +pub struct InvariantType; + +impl Copy for InvariantType {} +impl Clone for InvariantType { + fn clone(&self) -> InvariantType { *self } +} + +/// As `CovariantType`, but for lifetime parameters. Using +/// `CovariantLifetime<'a>` indicates that it is ok to substitute +/// a *longer* lifetime for `'a` than the one you originally +/// started with (e.g., you could convert any lifetime `'foo` to +/// `'static`). You almost certainly want `ContravariantLifetime` +/// instead, or possibly `InvariantLifetime`. The only case where +/// it would be appropriate is that you have a (type-casted, and +/// hence hidden from the type system) function pointer with a +/// signature like `fn(&'a T)` (and no other uses of `'a`). In +/// this case, it is ok to substitute a larger lifetime for `'a` +/// (e.g., `fn(&'static T)`), because the function is only +/// becoming more selective in terms of what it accepts as +/// argument. +/// +/// For more information about variance, refer to this Wikipedia +/// article . +#[lang="covariant_lifetime"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct CovariantLifetime<'a>; + +/// As `ContravariantType`, but for lifetime parameters. Using +/// `ContravariantLifetime<'a>` indicates that it is ok to +/// substitute a *shorter* lifetime for `'a` than the one you +/// originally started with (e.g., you could convert `'static` to +/// any lifetime `'foo`). This is appropriate for cases where you +/// have an unsafe pointer that is actually a pointer into some +/// memory with lifetime `'a`, and thus you want to limit the +/// lifetime of your data structure to `'a`. An example of where +/// this is used is the iterator for vectors. +/// +/// For more information about variance, refer to this Wikipedia +/// article . +#[lang="contravariant_lifetime"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct ContravariantLifetime<'a>; + +/// As `InvariantType`, but for lifetime parameters. Using +/// `InvariantLifetime<'a>` indicates that it is not ok to +/// substitute any other lifetime for `'a` besides its original +/// value. This is appropriate for cases where you have an unsafe +/// pointer that is actually a pointer into memory with lifetime `'a`, +/// and this pointer is itself stored in an inherently mutable +/// location (such as a `Cell`). +#[lang="invariant_lifetime"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct InvariantLifetime<'a>; + +/// A type which is considered "not sendable", meaning that it cannot +/// be safely sent between tasks, even if it is owned. This is +/// typically embedded in other types, such as `Gc`, to ensure that +/// their instances remain thread-local. +#[lang="no_send_bound"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct NoSend; + +/// A type which is considered "not POD", meaning that it is not +/// implicitly copyable. This is typically embedded in other types to +/// ensure that they are never copied, even if they lack a destructor. +#[lang="no_copy_bound"] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] +#[allow(missing_copy_implementations)] +pub struct NoCopy; + +/// A type which is considered "not sync", meaning that +/// its contents are not threadsafe, hence they cannot be +/// shared between tasks. +#[lang="no_sync_bound"] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub struct NoSync; + +/// A type which is considered managed by the GC. This is typically +/// embedded in other types. +#[lang="managed_bound"] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] +#[allow(missing_copy_implementations)] +pub struct Managed; diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index c60569161213f..24cb649ce55e4 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -15,7 +15,7 @@ #![stable] -use kinds::Sized; +use markers::Sized; use intrinsics; use ptr; diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 192d6063f6bbc..258337410246d 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -21,7 +21,7 @@ use cmp::{PartialEq, Eq}; use cmp::{PartialOrd, Ord}; use intrinsics; use iter::IteratorExt; -use kinds::Copy; +use markers::Copy; use mem::size_of; use ops::{Add, Sub, Mul, Div, Rem, Neg}; use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; @@ -992,7 +992,7 @@ impl_to_primitive_float! { f64 } /// A generic trait for converting a number to a value. #[experimental = "trait is likely to be removed"] -pub trait FromPrimitive : ::kinds::Sized { +pub trait FromPrimitive : ::markers::Sized { /// Convert an `int` to return an optional value of this type. If the /// value cannot be represented by this value, the `None` is returned. #[inline] diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 97d94e73bb33a..287a725a33c26 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -63,7 +63,7 @@ use clone::Clone; use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator}; -use kinds::Sized; +use markers::Sized; use option::Option::{self, Some, None}; /// The `Drop` trait is used to run some code when a value goes out of scope. This diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index e88cb73c8a9b7..558e451ee8c2a 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -29,7 +29,7 @@ //! ``` // Reexported core operators -pub use kinds::{Copy, Send, Sized, Sync}; +pub use markers::{Copy, Send, Sized, Sync}; pub use ops::{Drop, Fn, FnMut, FnOnce}; // Reexported functions diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 0b77f3456b2f5..40c7d60a2057c 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -92,7 +92,7 @@ use mem; use clone::Clone; use intrinsics; use option::Option::{self, Some, None}; -use kinds::{Send, Sized, Sync}; +use markers::{Send, Sized, Sync}; use cmp::{PartialEq, Eq, Ord, PartialOrd}; use cmp::Ordering::{self, Less, Equal, Greater}; diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 5ef6f6b2623aa..57f1706dc4368 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -18,7 +18,7 @@ //! //! Their definition should always match the ABI defined in `rustc::back::abi`. -use kinds::Copy; +use markers::Copy; use mem; /// The representation of a Rust slice diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 093ed0b242f5f..e4a15d385359c 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -41,7 +41,7 @@ use cmp::Ordering::{Less, Equal, Greater}; use cmp; use default::Default; use iter::*; -use kinds::Copy; +use markers::Copy; use num::Int; use ops::{FnMut, self}; use option::Option; @@ -52,7 +52,7 @@ use ptr; use ptr::PtrExt; use mem; use mem::size_of; -use kinds::{Sized, marker}; +use markers::{Sized, self}; use raw::Repr; // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module. use raw::Slice as RawSlice; @@ -169,11 +169,11 @@ impl SliceExt for [T] { if mem::size_of::() == 0 { Iter {ptr: p, end: (p as uint + self.len()) as *const T, - marker: marker::ContravariantLifetime::<'a>} + marker: markers::ContravariantLifetime::<'a>} } else { Iter {ptr: p, end: p.offset(self.len() as int), - marker: marker::ContravariantLifetime::<'a>} + marker: markers::ContravariantLifetime::<'a>} } } } @@ -322,11 +322,11 @@ impl SliceExt for [T] { if mem::size_of::() == 0 { IterMut {ptr: p, end: (p as uint + self.len()) as *mut T, - marker: marker::ContravariantLifetime::<'a>} + marker: markers::ContravariantLifetime::<'a>} } else { IterMut {ptr: p, end: p.offset(self.len() as int), - marker: marker::ContravariantLifetime::<'a>} + marker: markers::ContravariantLifetime::<'a>} } } } @@ -734,7 +734,7 @@ macro_rules! make_slice { pub struct Iter<'a, T: 'a> { ptr: *const T, end: *const T, - marker: marker::ContravariantLifetime<'a> + marker: markers::ContravariantLifetime<'a> } #[experimental] @@ -809,7 +809,7 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> { pub struct IterMut<'a, T: 'a> { ptr: *mut T, end: *mut T, - marker: marker::ContravariantLifetime<'a>, + marker: markers::ContravariantLifetime<'a>, } #[experimental] diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a39787b8207b5..f1f3cabb66b10 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -23,7 +23,7 @@ use default::Default; use iter::range; use iter::ExactSizeIterator; use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator}; -use kinds::Sized; +use markers::Sized; use mem; use num::Int; use ops::{Fn, FnMut}; diff --git a/src/libcore/ty.rs b/src/libcore/ty.rs index f8e03662b00ec..9de3cf30dc9af 100644 --- a/src/libcore/ty.rs +++ b/src/libcore/ty.rs @@ -10,4 +10,4 @@ //! Types dealing with unsafe actions. -use kinds::marker; +use markers; diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs index a4bafe754ffdd..3af38f9035dd4 100644 --- a/src/libcoretest/hash/mod.rs +++ b/src/libcoretest/hash/mod.rs @@ -7,7 +7,7 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. -use core::kinds::Sized; +use core::markers::Sized; use std::mem; use core::slice::SliceExt; diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index f86c85f821638..57e0737e909c9 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -12,7 +12,7 @@ use core::cmp::PartialEq; use core::fmt::Show; use core::num::{NumCast, cast}; use core::ops::{Add, Sub, Mul, Div, Rem}; -use core::kinds::Copy; +use core::markers::Copy; #[cfg_attr(stage0, macro_escape)] #[cfg_attr(not(stage0), macro_use)] diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs index 4a459992098a0..5588fbce26ad0 100644 --- a/src/libcoretest/option.rs +++ b/src/libcoretest/option.rs @@ -9,7 +9,7 @@ // except according to those terms. use core::option::*; -use core::kinds::marker; +use core::markers; use core::mem; use core::clone::Clone; @@ -82,7 +82,7 @@ fn test_option_dance() { #[test] #[should_fail] fn test_option_too_much_dance() { - let mut y = Some(marker::NoCopy); + let mut y = Some(markers::NoCopy); let _y2 = y.take().unwrap(); let _y3 = y.take().unwrap(); } diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index e3f02146a75f4..4255114243cf5 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -5081,5 +5081,7 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre #[doc(hidden)] #[cfg(not(test))] mod std { - pub use core::kinds; + #[cfg(stage0)] + pub use core::markers as kinds; + pub use core::markers; } diff --git a/src/librand/lib.rs b/src/librand/lib.rs index c4dd08f9917e2..9e900fcb3db0f 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -516,7 +516,9 @@ pub struct Closed01(pub F); mod std { pub use core::{option, fmt}; // panic!() pub use core::clone; // derive Clone - pub use core::kinds; + #[cfg(stage0)] + pub use core::markers as kinds; + pub use core::markers; } #[cfg(test)] diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index df2a4e4c2532a..780e3da468428 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -29,7 +29,7 @@ use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam}; use middle::ty::{MethodStatic, MethodStaticUnboxedClosure}; use util::ppaux::Repr; -use std::kinds; +use std::markers; use syntax::{ast, ast_util}; use syntax::ptr::P; use syntax::codemap::Span; @@ -135,7 +135,7 @@ enum TrackMatchMode { Conflicting, } -impl kinds::Copy for TrackMatchMode {} +impl markers::Copy for TrackMatchMode {} impl TrackMatchMode { // Builds up the whole match mode for a pattern from its constituent diff --git a/src/librustc/middle/infer/unify.rs b/src/librustc/middle/infer/unify.rs index 73da96445934c..b73142b405147 100644 --- a/src/librustc/middle/infer/unify.rs +++ b/src/librustc/middle/infer/unify.rs @@ -10,7 +10,7 @@ pub use self::VarValue::*; -use std::kinds::marker; +use std::markers; use middle::ty::{expected_found, IntVarValue}; use middle::ty::{self, Ty}; @@ -78,7 +78,7 @@ pub struct UnificationTable { /// made during the snapshot may either be *committed* or *rolled back*. pub struct Snapshot { // Link snapshot to the key type `K` of the table. - marker: marker::CovariantType, + marker: markers::CovariantType, snapshot: sv::Snapshot, } @@ -108,7 +108,7 @@ impl<'tcx, V:PartialEq+Clone+Repr<'tcx>, K:UnifyKey<'tcx, V>> UnificationTable Snapshot { - Snapshot { marker: marker::CovariantType::, + Snapshot { marker: markers::CovariantType::, snapshot: self.values.start_snapshot() } } diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index e58c2275fcd96..62c46c435bc7e 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -402,8 +402,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for TermsContext<'a, 'tcx> { struct ConstraintContext<'a, 'tcx: 'a> { terms_cx: TermsContext<'a, 'tcx>, - // These are the def-id of the std::kinds::marker::InvariantType, - // std::kinds::marker::InvariantLifetime, and so on. The arrays + // These are the def-id of the std::markers::InvariantType, + // std::markers::InvariantLifetime, and so on. The arrays // are indexed by the `ParamKind` (type, lifetime, self). Note // that there are no marker types for self, so the entries for // self are always None. diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index a3fc38c34e84f..ce9857f8243c8 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -21,7 +21,7 @@ use default::Default; use fmt::{self, Show}; use hash::{Hash, Hasher, RandomSipHasher}; use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map}; -use kinds::Sized; +use markers::Sized; use mem::{self, replace}; use num::{Int, UnsignedInt}; use ops::{Deref, FnMut, Index, IndexMut}; diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 211bfe2c10e8f..d67581a12b3ed 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -13,7 +13,7 @@ use borrow::BorrowFrom; use clone::Clone; use cmp::{Eq, PartialEq}; -use core::kinds::Sized; +use core::markers::Sized; use default::Default; use fmt::Show; use fmt; diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 1eb4408eedc40..cdfde1958c686 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -16,7 +16,7 @@ use clone::Clone; use cmp; use hash::{Hash, Hasher}; use iter::{Iterator, count}; -use kinds::{Copy, Sized, marker}; +use markers::{Copy, Sized, self}; use mem::{min_align_of, size_of}; use mem; use num::{Int, UnsignedInt}; @@ -72,7 +72,7 @@ pub struct RawTable { hashes: Unique, // Because K/V do not appear directly in any of the types in the struct, // inform rustc that in fact instances of K and V are reachable from here. - marker: marker::CovariantType<(K,V)>, + marker: markers::CovariantType<(K,V)>, } struct RawBucket { @@ -562,7 +562,7 @@ impl RawTable { size: 0, capacity: 0, hashes: Unique::null(), - marker: marker::CovariantType, + marker: markers::CovariantType, }; } // No need for `checked_mul` before a more restrictive check performed @@ -601,7 +601,7 @@ impl RawTable { capacity: capacity, size: 0, hashes: Unique(hashes), - marker: marker::CovariantType, + marker: markers::CovariantType, } } @@ -651,7 +651,7 @@ impl RawTable { hashes_end: unsafe { self.hashes.0.offset(self.capacity as int) }, - marker: marker::ContravariantLifetime, + marker: markers::ContravariantLifetime, } } @@ -676,7 +676,7 @@ impl RawTable { iter: RawBuckets { raw: raw, hashes_end: hashes_end, - marker: marker::ContravariantLifetime, + marker: markers::ContravariantLifetime, }, table: self, } @@ -689,7 +689,7 @@ impl RawTable { iter: RawBuckets { raw: raw, hashes_end: hashes_end, - marker: marker::ContravariantLifetime::<'static>, + marker: markers::ContravariantLifetime::<'static>, }, table: self, } @@ -703,7 +703,7 @@ impl RawTable { raw: raw_bucket.offset(self.capacity as int), hashes_end: raw_bucket.hash, elems_left: self.size, - marker: marker::ContravariantLifetime, + marker: markers::ContravariantLifetime, } } } @@ -713,7 +713,7 @@ impl RawTable { struct RawBuckets<'a, K, V> { raw: RawBucket, hashes_end: *mut u64, - marker: marker::ContravariantLifetime<'a>, + marker: markers::ContravariantLifetime<'a>, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -722,7 +722,7 @@ impl<'a, K, V> Clone for RawBuckets<'a, K, V> { RawBuckets { raw: self.raw, hashes_end: self.hashes_end, - marker: marker::ContravariantLifetime, + marker: markers::ContravariantLifetime, } } } @@ -754,7 +754,7 @@ struct RevMoveBuckets<'a, K, V> { raw: RawBucket, hashes_end: *mut u64, elems_left: uint, - marker: marker::ContravariantLifetime<'a>, + marker: markers::ContravariantLifetime<'a>, } impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> { diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs index ac2b01e995e2c..34facdc7de654 100644 --- a/src/libstd/hash.rs +++ b/src/libstd/hash.rs @@ -63,7 +63,7 @@ pub use core::hash::{Hash, Hasher, Writer, hash, sip}; -use core::kinds::Sized; +use core::markers::Sized; use default::Default; use rand::Rng; use rand; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 5bef473db990c..deae56d8a30d3 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -232,7 +232,7 @@ use error::{FromError, Error}; use fmt; use int; use iter::{Iterator, IteratorExt}; -use kinds::Sized; +use markers::Sized; use mem::transmute; use ops::FnOnce; use option::Option; diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index f571bed3ba226..43d37543e16a7 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -34,7 +34,7 @@ use failure::LOCAL_STDERR; use fmt; use io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer, standard_error, EndOfFile, LineBufferedWriter, BufferedReader}; -use kinds::{Sync, Send}; +use markers::{Sync, Send}; use libc; use mem; use option::Option; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b9f226c5aca73..b258c13f12e32 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -18,7 +18,7 @@ //! //! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html) //! modules deal with unsafe pointers and memory manipulation. -//! [`kinds`](kinds/index.html) defines the special built-in traits, +//! [`markers`](markers/index.html) defines the special built-in traits, //! and [`raw`](raw/index.html) the runtime representation of Rust types. //! These are some of the lowest-level building blocks in Rust. //! @@ -151,7 +151,7 @@ extern crate libc; // Make std testable by not duplicating lang items. See #2912 #[cfg(test)] extern crate "std" as realstd; -#[cfg(test)] pub use realstd::kinds; +#[cfg(test)] pub use realstd::markers; #[cfg(test)] pub use realstd::ops; #[cfg(test)] pub use realstd::cmp; #[cfg(test)] pub use realstd::boxed; @@ -168,7 +168,8 @@ pub use core::default; pub use core::finally; pub use core::intrinsics; pub use core::iter; -#[cfg(not(test))] pub use core::kinds; +#[cfg(stage0)] #[cfg(not(test))] pub use core::markers as kinds; +#[cfg(not(test))] pub use core::markers; pub use core::mem; #[cfg(not(test))] pub use core::ops; pub use core::ptr; @@ -311,7 +312,9 @@ mod std { pub use vec; // used for vec![] pub use cell; // used for tls! pub use thread_local; // used for thread_local! - pub use kinds; // used for tls! + #[cfg(stage0)] + pub use markers as kinds; + pub use markers; // used for tls! pub use ops; // used for bitflags! // The test runner calls ::std::os::args() but really wants realstd diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index e3402984ae505..cd78489cb8513 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -19,7 +19,7 @@ #[cfg(test)] use fmt::Show; use ops::{Add, Sub, Mul, Div, Rem, Neg}; -use kinds::Copy; +use markers::Copy; use clone::Clone; use cmp::{PartialOrd, PartialEq}; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 300ceec4b45bf..0e41d608086e9 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -37,7 +37,7 @@ use error::{FromError, Error}; use fmt; use io::{IoResult, IoError}; use iter::{Iterator, IteratorExt}; -use kinds::Copy; +use markers::Copy; use libc::{c_void, c_int, c_char}; use libc; use boxed::Box; diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index b020164158cff..e263761acd1c7 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -61,7 +61,7 @@ #![experimental] -use core::kinds::Sized; +use core::markers::Sized; use ffi::CString; use clone::Clone; use fmt; diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index d9981ace0301e..03811364d30c2 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -16,7 +16,7 @@ use hash; use io::Writer; use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map}; -use kinds::Sized; +use markers::Sized; use option::Option::{self, Some, None}; use slice::{AsSlice, Split, SliceExt, SliceConcatExt}; use str::{self, FromStr, StrExt}; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index 9e9a483e1a5e3..bf8d2a3d63b9c 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -13,7 +13,7 @@ #![stable] // Reexported core operators -#[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync}; +#[stable] #[doc(no_inline)] pub use markers::{Copy, Send, Sized, Sync}; #[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; // Reexported functions diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index a79a6e35ebcfd..512bd2a3d6e9b 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -185,7 +185,7 @@ mod imp { extern crate libc; use io::{IoResult}; - use kinds::Sync; + use markers::Sync; use mem; use os; use rand::Rng; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index e556888a470a2..036bb7b637b67 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -23,7 +23,7 @@ #![allow(dead_code)] -use kinds::Send; +use markers::Send; use ops::FnOnce; use sys; use thunk::Thunk; diff --git a/src/libstd/sync/mpsc/blocking.rs b/src/libstd/sync/mpsc/blocking.rs index faff5f09f81e1..af6aa803f9969 100644 --- a/src/libstd/sync/mpsc/blocking.rs +++ b/src/libstd/sync/mpsc/blocking.rs @@ -13,8 +13,8 @@ use thread::Thread; use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering}; use sync::Arc; -use kinds::{Sync, Send}; -use kinds::marker::{NoSend, NoSync}; +use markers::{Sync, Send}; +use markers::{NoSend, NoSync}; use mem; use clone::Clone; diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 7c18b8a43faad..4d18d9e6e9d67 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -319,7 +319,7 @@ use prelude::v1::*; use sync::Arc; use fmt; -use kinds::marker; +use markers; use mem; use cell::UnsafeCell; @@ -373,7 +373,7 @@ unsafe impl Send for Sender { } pub struct SyncSender { inner: Arc>>, // can't share in an arc - _marker: marker::NoSync, + _marker: markers::NoSync, } /// An error returned from the `send` function on channels. @@ -678,7 +678,7 @@ impl Drop for Sender { impl SyncSender { fn new(inner: Arc>>) -> SyncSender { - SyncSender { inner: inner, _marker: marker::NoSync } + SyncSender { inner: inner, _marker: markers::NoSync } } /// Sends a value on this synchronous channel. diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index 16adbf5aa4f69..ca7120b5ead8f 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -57,7 +57,7 @@ use core::prelude::*; use core::cell::Cell; -use core::kinds::marker; +use core::markers; use core::mem; use core::uint; @@ -70,7 +70,7 @@ pub struct Select { head: *mut Handle<'static, ()>, tail: *mut Handle<'static, ()>, next_id: Cell, - marker1: marker::NoSend, + marker1: markers::NoSend, } /// A handle to a receiver which is currently a member of a `Select` set of @@ -115,7 +115,7 @@ impl Select { /// rather much easier through the `select!` macro. pub fn new() -> Select { Select { - marker1: marker::NoSend, + marker1: markers::NoSend, head: 0 as *mut Handle<'static, ()>, tail: 0 as *mut Handle<'static, ()>, next_id: Cell::new(1), diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 6b3dd89f33b07..bb5a633764690 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -11,7 +11,7 @@ use prelude::v1::*; use cell::UnsafeCell; -use kinds::marker; +use markers; use ops::{Deref, DerefMut}; use sync::poison::{self, TryLockError, TryLockResult, LockResult}; use sys_common::mutex as sys; @@ -166,7 +166,7 @@ pub struct MutexGuard<'a, T: 'a> { __lock: &'a StaticMutex, __data: &'a UnsafeCell, __poison: poison::Guard, - __marker: marker::NoSend, + __marker: markers::NoSend, } /// Static initialization of a mutex. This constant can be used to initialize @@ -286,7 +286,7 @@ impl<'mutex, T> MutexGuard<'mutex, T> { __lock: lock, __data: data, __poison: guard, - __marker: marker::NoSend, + __marker: markers::NoSend, } }) } diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index aa2d957a3eb5e..11a5cad2c25f1 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -14,7 +14,7 @@ //! example use case would be for initializing an FFI library. use int; -use kinds::Sync; +use markers::Sync; use mem::drop; use ops::FnOnce; use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT}; diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 4afd5bb63f4fe..f40c0cc0c0e53 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -11,7 +11,7 @@ use prelude::v1::*; use cell::UnsafeCell; -use kinds::marker; +use markers; use ops::{Deref, DerefMut}; use sync::poison::{self, LockResult, TryLockError, TryLockResult}; use sys_common::rwlock as sys; @@ -113,7 +113,7 @@ pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock { pub struct RwLockReadGuard<'a, T: 'a> { __lock: &'a StaticRwLock, __data: &'a UnsafeCell, - __marker: marker::NoSend, + __marker: markers::NoSend, } /// RAII structure used to release the exclusive write access of a lock when @@ -124,7 +124,7 @@ pub struct RwLockWriteGuard<'a, T: 'a> { __lock: &'a StaticRwLock, __data: &'a UnsafeCell, __poison: poison::Guard, - __marker: marker::NoSend, + __marker: markers::NoSend, } impl RwLock { @@ -309,7 +309,7 @@ impl<'rwlock, T> RwLockReadGuard<'rwlock, T> { RwLockReadGuard { __lock: lock, __data: data, - __marker: marker::NoSend, + __marker: markers::NoSend, } }) } @@ -322,7 +322,7 @@ impl<'rwlock, T> RwLockWriteGuard<'rwlock, T> { __lock: lock, __data: data, __poison: guard, - __marker: marker::NoSend, + __marker: markers::NoSend, } }) } diff --git a/src/libstd/sys/common/mutex.rs b/src/libstd/sys/common/mutex.rs index 567c26956efe9..b86e6ce254a53 100644 --- a/src/libstd/sys/common/mutex.rs +++ b/src/libstd/sys/common/mutex.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use kinds::Sync; +use markers::Sync; use sys::mutex as imp; /// An OS-based mutual exclusion lock. diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index ca419d1c7f436..968347bbfbcb1 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -165,8 +165,8 @@ mod signal { sa_restorer: *mut libc::c_void, } - unsafe impl ::kinds::Send for sigaction { } - unsafe impl ::kinds::Sync for sigaction { } + unsafe impl ::markers::Send for sigaction { } + unsafe impl ::markers::Sync for sigaction { } #[repr(C)] #[cfg(target_word_size = "32")] @@ -217,8 +217,8 @@ mod signal { sa_resv: [libc::c_int; 1], } - unsafe impl ::kinds::Send for sigaction { } - unsafe impl ::kinds::Sync for sigaction { } + unsafe impl ::markers::Send for sigaction { } + unsafe impl ::markers::Sync for sigaction { } #[repr(C)] pub struct sigset_t { diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs index 81f8659d6ae08..8da25c7880dfd 100644 --- a/src/libstd/sys/unix/mutex.rs +++ b/src/libstd/sys/unix/mutex.rs @@ -9,7 +9,7 @@ // except according to those terms. use cell::UnsafeCell; -use kinds::Sync; +use markers::Sync; use sys::sync as ffi; use sys_common::mutex; diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index cc82d38ae2af1..630087e2291a5 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -128,7 +128,7 @@ use any::Any; use boxed::Box; use cell::UnsafeCell; use clone::Clone; -use kinds::{Send, Sync}; +use markers::{Send, Sync}; use ops::{Drop, FnOnce}; use option::Option::{self, Some, None}; use result::Result::{Err, Ok}; diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs index e0cbaa8ca50ed..bf01b578b1fb7 100644 --- a/src/libstd/thread_local/mod.rs +++ b/src/libstd/thread_local/mod.rs @@ -346,7 +346,7 @@ mod imp { pub dtor_running: UnsafeCell, // should be Cell } - unsafe impl ::kinds::Sync for Key { } + unsafe impl ::markers::Sync for Key { } #[doc(hidden)] impl Key { @@ -472,7 +472,7 @@ mod imp { pub os: OsStaticKey, } - unsafe impl ::kinds::Sync for Key { } + unsafe impl ::markers::Sync for Key { } struct Value { key: &'static Key, diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs index 714b71d5dbd4e..a643d2cb8ee36 100644 --- a/src/libstd/thread_local/scoped.rs +++ b/src/libstd/thread_local/scoped.rs @@ -108,7 +108,7 @@ macro_rules! __scoped_thread_local_inner { const _INIT: __Key<$t> = __Key { inner: ::std::thread_local::scoped::__impl::KeyInner { inner: ::std::thread_local::scoped::__impl::OS_INIT, - marker: ::std::kinds::marker::InvariantType, + marker: ::std::markers::InvariantType, } }; @@ -211,7 +211,7 @@ mod imp { #[doc(hidden)] pub struct KeyInner { pub inner: UnsafeCell<*mut T> } - unsafe impl ::kinds::Sync for KeyInner { } + unsafe impl ::markers::Sync for KeyInner { } #[doc(hidden)] impl KeyInner { @@ -224,16 +224,16 @@ mod imp { #[cfg(any(windows, target_os = "android", target_os = "ios", target_arch = "aarch64"))] mod imp { - use kinds::marker; + use markers; use sys_common::thread_local::StaticKey as OsStaticKey; #[doc(hidden)] pub struct KeyInner { pub inner: OsStaticKey, - pub marker: marker::InvariantType, + pub marker: markers::InvariantType, } - unsafe impl ::kinds::Sync for KeyInner { } + unsafe impl ::markers::Sync for KeyInner { } #[doc(hidden)] impl KeyInner { diff --git a/src/libstd/thunk.rs b/src/libstd/thunk.rs index 067926042f121..ec9dd86f94107 100644 --- a/src/libstd/thunk.rs +++ b/src/libstd/thunk.rs @@ -12,7 +12,7 @@ #![allow(missing_docs)] use alloc::boxed::Box; -use core::kinds::Send; +use core::markers::Send; use core::ops::FnOnce; pub struct Thunk { diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs index cf29bb048d644..50c91c133437d 100644 --- a/src/libsyntax/ext/deriving/bounds.rs +++ b/src/libsyntax/ext/deriving/bounds.rs @@ -47,7 +47,7 @@ pub fn expand_deriving_bound(cx: &mut ExtCtxt, let trait_def = TraitDef { span: span, attributes: Vec::new(), - path: Path::new(vec!("std", "kinds", name)), + path: Path::new(vec!("std", "markers", name)), additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), methods: vec!() diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs index c755ea9318402..094d45a10d166 100644 --- a/src/libunicode/tables.rs +++ b/src/libunicode/tables.rs @@ -7801,7 +7801,7 @@ pub mod charwidth { } pub mod grapheme { - use core::kinds::Copy; + use core::markers::Copy; use core::slice::SliceExt; pub use self::GraphemeCat::*; use core::result::Result::{Ok, Err}; diff --git a/src/test/compile-fail/associated-types-unsized.rs b/src/test/compile-fail/associated-types-unsized.rs index db39eafc1912b..28483abda3cfe 100644 --- a/src/test/compile-fail/associated-types-unsized.rs +++ b/src/test/compile-fail/associated-types-unsized.rs @@ -14,7 +14,7 @@ trait Get { } fn foo(t: T) { - let x = t.get(); //~ ERROR the trait `core::kinds::Sized` is not implemented + let x = t.get(); //~ ERROR the trait `core::markers::Sized` is not implemented } fn main() { diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs index cf07dc02b9609..33907dc4c4667 100644 --- a/src/test/compile-fail/bad-method-typaram-kind.rs +++ b/src/test/compile-fail/bad-method-typaram-kind.rs @@ -9,7 +9,7 @@ // except according to those terms. fn foo() { - 1u.bar::(); //~ ERROR `core::kinds::Send` is not implemented + 1u.bar::(); //~ ERROR `core::markers::Send` is not implemented } trait bar { diff --git a/src/test/compile-fail/bad-sized.rs b/src/test/compile-fail/bad-sized.rs index 4e0ad8088bee4..6e8fcba8c8a15 100644 --- a/src/test/compile-fail/bad-sized.rs +++ b/src/test/compile-fail/bad-sized.rs @@ -16,8 +16,8 @@ trait Trait {} pub fn main() { let x: Vec = Vec::new(); - //~^ ERROR the trait `core::kinds::Sized` is not implemented - //~^^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented + //~^^ ERROR the trait `core::markers::Sized` is not implemented let x: Vec>> = Vec::new(); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } diff --git a/src/test/compile-fail/borrowck-move-out-of-static-item.rs b/src/test/compile-fail/borrowck-move-out-of-static-item.rs index ea36c76ea4058..310da28dd4963 100644 --- a/src/test/compile-fail/borrowck-move-out-of-static-item.rs +++ b/src/test/compile-fail/borrowck-move-out-of-static-item.rs @@ -10,14 +10,14 @@ // Ensure that moves out of static items is forbidden -use std::kinds::marker; +use std::markers; struct Foo { foo: int, - nocopy: marker::NoCopy + nocopy: markers::NoCopy } -static BAR: Foo = Foo{foo: 5, nocopy: marker::NoCopy}; +static BAR: Foo = Foo{foo: 5, nocopy: markers::NoCopy}; fn test(f: Foo) { diff --git a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs index 23cd4d80724e0..36d430ddeaa63 100644 --- a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs +++ b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs @@ -12,7 +12,7 @@ // move, when the struct implements Drop. // NoCopy -use std::kinds::marker::NoCopy as NP; +use std::markers::NoCopy as NP; struct S { a: int, np: NP } diff --git a/src/test/compile-fail/builtin-superkinds-double-superkind.rs b/src/test/compile-fail/builtin-superkinds-double-superkind.rs index f3b9c395e4514..03c1aa2a05d68 100644 --- a/src/test/compile-fail/builtin-superkinds-double-superkind.rs +++ b/src/test/compile-fail/builtin-superkinds-double-superkind.rs @@ -13,9 +13,9 @@ trait Foo : Send+Sync { } -impl Foo for (T,) { } //~ ERROR the trait `core::kinds::Send` is not implemented +impl Foo for (T,) { } //~ ERROR the trait `core::markers::Send` is not implemented -impl Foo for (T,T) { } //~ ERROR the trait `core::kinds::Sync` is not implemented +impl Foo for (T,T) { } //~ ERROR the trait `core::markers::Sync` is not implemented impl Foo for (T,T,T) { } // (ok) diff --git a/src/test/compile-fail/builtin-superkinds-in-metadata.rs b/src/test/compile-fail/builtin-superkinds-in-metadata.rs index 76835c9955f6e..1fa663640d869 100644 --- a/src/test/compile-fail/builtin-superkinds-in-metadata.rs +++ b/src/test/compile-fail/builtin-superkinds-in-metadata.rs @@ -22,6 +22,6 @@ struct X(T); impl RequiresShare for X { } impl RequiresRequiresShareAndSend for X { } -//~^ ERROR the trait `core::kinds::Send` is not implemented +//~^ ERROR the trait `core::markers::Send` is not implemented fn main() { } diff --git a/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs b/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs index e77177f7f6d29..2c295768e7ad5 100644 --- a/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs +++ b/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs @@ -12,6 +12,6 @@ trait Foo : Send { } -impl Foo for T { } //~ ERROR the trait `core::kinds::Send` is not implemented +impl Foo for T { } //~ ERROR the trait `core::markers::Send` is not implemented fn main() { } diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs index 54dccebe69953..8b7d2457d3cdc 100644 --- a/src/test/compile-fail/check-static-values-constraints.rs +++ b/src/test/compile-fail/check-static-values-constraints.rs @@ -10,7 +10,7 @@ // Verifies all possible restrictions for statics values. -use std::kinds::marker; +use std::markers; struct WithDtor; diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs index 2e535b3950938..5dce6ba81333b 100644 --- a/src/test/compile-fail/comm-not-freeze-receiver.rs +++ b/src/test/compile-fail/comm-not-freeze-receiver.rs @@ -13,5 +13,5 @@ use std::sync::mpsc::Receiver; fn test() {} fn main() { - test::>(); //~ ERROR: `core::kinds::Sync` is not implemented + test::>(); //~ ERROR: `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs index 1b1c43e4793e3..0f34ccf4a523a 100644 --- a/src/test/compile-fail/comm-not-freeze.rs +++ b/src/test/compile-fail/comm-not-freeze.rs @@ -13,5 +13,5 @@ use std::sync::mpsc::Sender; fn test() {} fn main() { - test::>(); //~ ERROR: `core::kinds::Sync` is not implemented + test::>(); //~ ERROR: `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs index 5e360b6ab9bad..b9c06c60a5dcb 100644 --- a/src/test/compile-fail/dst-bad-assign-2.rs +++ b/src/test/compile-fail/dst-bad-assign-2.rs @@ -43,5 +43,5 @@ pub fn main() { let f5: &mut Fat = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} }; let z: Box = box Bar1 {f: 36}; f5.ptr = *z; - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs index cc709be99002e..2516d9874550f 100644 --- a/src/test/compile-fail/dst-bad-assign.rs +++ b/src/test/compile-fail/dst-bad-assign.rs @@ -43,5 +43,5 @@ pub fn main() { let f5: &mut Fat = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} }; let z: Box = box Bar1 {f: 36}; f5.ptr = Bar1 {f: 36}; //~ ERROR mismatched types: expected `ToBar`, found `Bar1` - //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `ToBar` + //~^ ERROR the trait `core::markers::Sized` is not implemented for the type `ToBar` } diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs index b169824cb3aca..ed2ccc9d9cc42 100644 --- a/src/test/compile-fail/dst-bad-deep.rs +++ b/src/test/compile-fail/dst-bad-deep.rs @@ -21,5 +21,5 @@ pub fn main() { let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] }; let g: &Fat<[int]> = &f; let h: &Fat> = &Fat { ptr: *g }; - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } diff --git a/src/test/compile-fail/dst-object-from-unsized-type.rs b/src/test/compile-fail/dst-object-from-unsized-type.rs index 3c75b5b6eddb8..b28952d2b330e 100644 --- a/src/test/compile-fail/dst-object-from-unsized-type.rs +++ b/src/test/compile-fail/dst-object-from-unsized-type.rs @@ -15,22 +15,22 @@ impl Foo for str {} fn test1(t: &T) { let u: &Foo = t; - //~^ ERROR `core::kinds::Sized` is not implemented for the type `T` + //~^ ERROR `core::markers::Sized` is not implemented for the type `T` } fn test2(t: &T) { let v: &Foo = t as &Foo; - //~^ ERROR `core::kinds::Sized` is not implemented for the type `T` + //~^ ERROR `core::markers::Sized` is not implemented for the type `T` } fn test3() { let _: &[&Foo] = &["hi"]; - //~^ ERROR `core::kinds::Sized` is not implemented for the type `str` + //~^ ERROR `core::markers::Sized` is not implemented for the type `str` } fn test4() { let _: &Foo = "hi" as &Foo; - //~^ ERROR `core::kinds::Sized` is not implemented for the type `str` + //~^ ERROR `core::markers::Sized` is not implemented for the type `str` } fn main() { } diff --git a/src/test/compile-fail/dst-sized-trait-param.rs b/src/test/compile-fail/dst-sized-trait-param.rs index ea5becbf229c0..af0b780b3b779 100644 --- a/src/test/compile-fail/dst-sized-trait-param.rs +++ b/src/test/compile-fail/dst-sized-trait-param.rs @@ -15,9 +15,9 @@ trait Foo : Sized { fn take(self, x: &T) { } } // Note: T is sized impl Foo<[int]> for uint { } -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[int]` +//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[int]` impl Foo for [uint] { } -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[uint]` +//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[uint]` pub fn main() { } diff --git a/src/test/compile-fail/error-should-say-copy-not-pod.rs b/src/test/compile-fail/error-should-say-copy-not-pod.rs index 3d25c7ee772f6..581a06db7451a 100644 --- a/src/test/compile-fail/error-should-say-copy-not-pod.rs +++ b/src/test/compile-fail/error-should-say-copy-not-pod.rs @@ -13,5 +13,5 @@ fn check_bound(_: T) {} fn main() { - check_bound("nocopy".to_string()); //~ ERROR the trait `core::kinds::Copy` is not implemented + check_bound("nocopy".to_string()); //~ ERROR the trait `core::markers::Copy` is not implemented } diff --git a/src/test/compile-fail/issue-14366.rs b/src/test/compile-fail/issue-14366.rs index d03885ca7133c..d9b8c4db031d0 100644 --- a/src/test/compile-fail/issue-14366.rs +++ b/src/test/compile-fail/issue-14366.rs @@ -10,5 +10,5 @@ fn main() { let _x = "test" as &::std::any::Any; -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str` +//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `str` } diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs index 5be3b960ec635..5e305313fcf9b 100644 --- a/src/test/compile-fail/issue-15756.rs +++ b/src/test/compile-fail/issue-15756.rs @@ -15,7 +15,7 @@ fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>) { for &something -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[T]` +//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[T]` in arg2 { } diff --git a/src/test/compile-fail/issue-16538.rs b/src/test/compile-fail/issue-16538.rs index 0e022834bacf2..505a59b484db8 100644 --- a/src/test/compile-fail/issue-16538.rs +++ b/src/test/compile-fail/issue-16538.rs @@ -20,6 +20,6 @@ mod Y { static foo: *const Y::X = Y::foo(Y::x as *const Y::X); //~^ ERROR cannot refer to other statics by value -//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type +//~| ERROR: the trait `core::markers::Sync` is not implemented for the type fn main() {} diff --git a/src/test/compile-fail/issue-17718-static-move.rs b/src/test/compile-fail/issue-17718-static-move.rs index c57df9a3af4a4..730344f5763cc 100644 --- a/src/test/compile-fail/issue-17718-static-move.rs +++ b/src/test/compile-fail/issue-17718-static-move.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; -struct Foo { nc: marker::NoCopy } -const INIT: Foo = Foo { nc: marker::NoCopy }; +struct Foo { nc: markers::NoCopy } +const INIT: Foo = Foo { nc: markers::NoCopy }; static FOO: Foo = INIT; fn main() { diff --git a/src/test/compile-fail/issue-17718-static-sync.rs b/src/test/compile-fail/issue-17718-static-sync.rs index 63a40e2374b15..da343cc81ac66 100644 --- a/src/test/compile-fail/issue-17718-static-sync.rs +++ b/src/test/compile-fail/issue-17718-static-sync.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; -struct Foo { marker: marker::NoSync } +struct Foo { marker: markers::NoSync } static FOO: uint = 3; -static BAR: Foo = Foo { marker: marker::NoSync }; -//~^ ERROR: the trait `core::kinds::Sync` is not implemented +static BAR: Foo = Foo { marker: markers::NoSync }; +//~^ ERROR: the trait `core::markers::Sync` is not implemented fn main() {} diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs index 6cebf7f9da14d..a17b2ee0c68a2 100644 --- a/src/test/compile-fail/issue-18107.rs +++ b/src/test/compile-fail/issue-18107.rs @@ -14,7 +14,7 @@ pub trait AbstractRenderer {} fn _create_render(_: &()) -> AbstractRenderer -//~^ ERROR: the trait `core::kinds::Sized` is not implemented +//~^ ERROR: the trait `core::markers::Sized` is not implemented { match 0u { _ => unimplemented!() diff --git a/src/test/compile-fail/issue-19883.rs b/src/test/compile-fail/issue-19883.rs index 70fe6b9b6a868..b9fbc37828f6b 100644 --- a/src/test/compile-fail/issue-19883.rs +++ b/src/test/compile-fail/issue-19883.rs @@ -18,13 +18,13 @@ trait To { // This is a typo, the return type should be `>::Output` fn to>( self - //~^ error: the trait `core::kinds::Sized` is not implemented + //~^ error: the trait `core::markers::Sized` is not implemented ) -> >::Dst - //~^ error: the trait `core::kinds::Sized` is not implemented + //~^ error: the trait `core::markers::Sized` is not implemented { From::from( - //~^ error: the trait `core::kinds::Sized` is not implemented + //~^ error: the trait `core::markers::Sized` is not implemented self ) } diff --git a/src/test/compile-fail/issue-20005.rs b/src/test/compile-fail/issue-20005.rs index b52f2b1b13857..8076df39db9a4 100644 --- a/src/test/compile-fail/issue-20005.rs +++ b/src/test/compile-fail/issue-20005.rs @@ -16,9 +16,9 @@ trait From { trait To { fn to( - self //~ error: the trait `core::kinds::Sized` is not implemented + self //~ error: the trait `core::markers::Sized` is not implemented ) -> >::Result where Dst: From { - From::from( //~ error: the trait `core::kinds::Sized` is not implemented + From::from( //~ error: the trait `core::markers::Sized` is not implemented self ) } diff --git a/src/test/compile-fail/issue-3907-2.rs b/src/test/compile-fail/issue-3907-2.rs index 981abf6cc23d8..da60fee65c6ab 100644 --- a/src/test/compile-fail/issue-3907-2.rs +++ b/src/test/compile-fail/issue-3907-2.rs @@ -17,6 +17,6 @@ struct S { name: int } -fn bar(_x: Foo) {} //~ ERROR the trait `core::kinds::Sized` is not implemented +fn bar(_x: Foo) {} //~ ERROR the trait `core::markers::Sized` is not implemented fn main() {} diff --git a/src/test/compile-fail/issue-5035-2.rs b/src/test/compile-fail/issue-5035-2.rs index d0830ff8e4d76..05073927beb62 100644 --- a/src/test/compile-fail/issue-5035-2.rs +++ b/src/test/compile-fail/issue-5035-2.rs @@ -11,6 +11,6 @@ trait I {} type K = I+'static; -fn foo(_x: K) {} //~ ERROR: the trait `core::kinds::Sized` is not implemented +fn foo(_x: K) {} //~ ERROR: the trait `core::markers::Sized` is not implemented fn main() {} diff --git a/src/test/compile-fail/issue-5543.rs b/src/test/compile-fail/issue-5543.rs index f970cdb1b8304..6981c4451ca13 100644 --- a/src/test/compile-fail/issue-5543.rs +++ b/src/test/compile-fail/issue-5543.rs @@ -14,5 +14,5 @@ impl Foo for u8 {} fn main() { let r: Box = box 5; let _m: Box = r as Box; - //~^ ERROR `core::kinds::Sized` is not implemented for the type `Foo` + //~^ ERROR `core::markers::Sized` is not implemented for the type `Foo` } diff --git a/src/test/compile-fail/issue-5883.rs b/src/test/compile-fail/issue-5883.rs index e6ac30139c37f..2f601a8ba58bb 100644 --- a/src/test/compile-fail/issue-5883.rs +++ b/src/test/compile-fail/issue-5883.rs @@ -15,8 +15,8 @@ struct Struct { } fn new_struct(r: A+'static) - -> Struct { //~^ ERROR the trait `core::kinds::Sized` is not implemented - //~^ ERROR the trait `core::kinds::Sized` is not implemented + -> Struct { //~^ ERROR the trait `core::markers::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented Struct { r: r } } diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs index a8a699d62d5ee..30a59c52faa8c 100644 --- a/src/test/compile-fail/issue-7013.rs +++ b/src/test/compile-fail/issue-7013.rs @@ -32,6 +32,6 @@ struct A { fn main() { let a = A {v: box B{v: None} as Box}; - //~^ ERROR the trait `core::kinds::Send` is not implemented - //~^^ ERROR the trait `core::kinds::Send` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented + //~^^ ERROR the trait `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs index 77836143f27dd..c4217029a9343 100644 --- a/src/test/compile-fail/issue-7364.rs +++ b/src/test/compile-fail/issue-7364.rs @@ -14,7 +14,7 @@ use std::cell::RefCell; // Regresion test for issue 7364 static boxed: Box> = box RefCell::new(0); //~^ ERROR statics are not allowed to have custom pointers -//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type -//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type +//~| ERROR: the trait `core::markers::Sync` is not implemented for the type +//~| ERROR: the trait `core::markers::Sync` is not implemented for the type fn main() { } diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs index b5725249812f6..583fbedfcbc51 100644 --- a/src/test/compile-fail/kindck-copy.rs +++ b/src/test/compile-fail/kindck-copy.rs @@ -36,14 +36,14 @@ fn test<'a,T,U:Copy>(_: &'a int) { assert_copy::<&'a [int]>(); // ...unless they are mutable - assert_copy::<&'static mut int>(); //~ ERROR `core::kinds::Copy` is not implemented - assert_copy::<&'a mut int>(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::<&'static mut int>(); //~ ERROR `core::markers::Copy` is not implemented + assert_copy::<&'a mut int>(); //~ ERROR `core::markers::Copy` is not implemented // ~ pointers are not ok - assert_copy::>(); //~ ERROR `core::kinds::Copy` is not implemented - assert_copy::(); //~ ERROR `core::kinds::Copy` is not implemented - assert_copy:: >(); //~ ERROR `core::kinds::Copy` is not implemented - assert_copy::>(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::>(); //~ ERROR `core::markers::Copy` is not implemented + assert_copy::(); //~ ERROR `core::markers::Copy` is not implemented + assert_copy:: >(); //~ ERROR `core::markers::Copy` is not implemented + assert_copy::>(); //~ ERROR `core::markers::Copy` is not implemented // borrowed object types are generally ok assert_copy::<&'a Dummy>(); @@ -51,11 +51,11 @@ fn test<'a,T,U:Copy>(_: &'a int) { assert_copy::<&'static (Dummy+Copy)>(); // owned object types are not ok - assert_copy::>(); //~ ERROR `core::kinds::Copy` is not implemented - assert_copy::>(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::>(); //~ ERROR `core::markers::Copy` is not implemented + assert_copy::>(); //~ ERROR `core::markers::Copy` is not implemented // mutable object types are not ok - assert_copy::<&'a mut (Dummy+Copy)>(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::<&'a mut (Dummy+Copy)>(); //~ ERROR `core::markers::Copy` is not implemented // unsafe ptrs are ok assert_copy::<*const int>(); @@ -73,10 +73,10 @@ fn test<'a,T,U:Copy>(_: &'a int) { assert_copy::(); // structs containing non-POD are not ok - assert_copy::(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::(); //~ ERROR `core::markers::Copy` is not implemented // ref counted types are not ok - assert_copy::>(); //~ ERROR `core::kinds::Copy` is not implemented + assert_copy::>(); //~ ERROR `core::markers::Copy` is not implemented } pub fn main() { diff --git a/src/test/compile-fail/kindck-impl-type-params-2.rs b/src/test/compile-fail/kindck-impl-type-params-2.rs index 6b25289567b27..2ec22ceb63fd7 100644 --- a/src/test/compile-fail/kindck-impl-type-params-2.rs +++ b/src/test/compile-fail/kindck-impl-type-params-2.rs @@ -19,5 +19,5 @@ fn take_param(foo: &T) { } fn main() { let x = box 3i; take_param(&x); - //~^ ERROR the trait `core::kinds::Copy` is not implemented + //~^ ERROR the trait `core::markers::Copy` is not implemented } diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs index 57ee4cf7cc3b0..ad62fd9856050 100644 --- a/src/test/compile-fail/kindck-impl-type-params.rs +++ b/src/test/compile-fail/kindck-impl-type-params.rs @@ -20,15 +20,15 @@ impl Gettable for S {} fn f(val: T) { let t: S = S; let a = &t as &Gettable; - //~^ ERROR the trait `core::kinds::Send` is not implemented - //~^^ ERROR the trait `core::kinds::Copy` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented + //~^^ ERROR the trait `core::markers::Copy` is not implemented } fn g(val: T) { let t: S = S; let a: &Gettable = &t; - //~^ ERROR the trait `core::kinds::Send` is not implemented - //~^^ ERROR the trait `core::kinds::Copy` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented + //~^^ ERROR the trait `core::markers::Copy` is not implemented } fn foo<'a>() { @@ -40,13 +40,13 @@ fn foo<'a>() { fn foo2<'a>() { let t: Box> = box S; let a = t as Box>; - //~^ ERROR the trait `core::kinds::Copy` is not implemented + //~^ ERROR the trait `core::markers::Copy` is not implemented } fn foo3<'a>() { let t: Box> = box S; let a: Box> = t; - //~^ ERROR the trait `core::kinds::Copy` is not implemented + //~^ ERROR the trait `core::markers::Copy` is not implemented } fn main() { } diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs index d66fd0d77d6a9..238f495187c5e 100644 --- a/src/test/compile-fail/kindck-inherited-copy-bound.rs +++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs @@ -22,13 +22,13 @@ fn take_param(foo: &T) { } fn a() { let x = box 3i; - take_param(&x); //~ ERROR `core::kinds::Copy` is not implemented + take_param(&x); //~ ERROR `core::markers::Copy` is not implemented } fn b() { let x = box 3i; let y = &x; - let z = &x as &Foo; //~ ERROR `core::kinds::Copy` is not implemented + let z = &x as &Foo; //~ ERROR `core::markers::Copy` is not implemented } fn main() { } diff --git a/src/test/compile-fail/kindck-nonsendable-1.rs b/src/test/compile-fail/kindck-nonsendable-1.rs index fdd8584a8bb06..b46f91413a41c 100644 --- a/src/test/compile-fail/kindck-nonsendable-1.rs +++ b/src/test/compile-fail/kindck-nonsendable-1.rs @@ -18,7 +18,7 @@ fn bar(_: F) { } fn main() { let x = Rc::new(3u); bar(move|| foo(x)); - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/kindck-send-object.rs b/src/test/compile-fail/kindck-send-object.rs index c300096caf1e0..1235a0a1228df 100644 --- a/src/test/compile-fail/kindck-send-object.rs +++ b/src/test/compile-fail/kindck-send-object.rs @@ -20,11 +20,11 @@ trait Message : Send { } fn object_ref_with_static_bound_not_ok() { assert_send::<&'static (Dummy+'static)>(); - //~^ ERROR the trait `core::kinds::Send` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented } fn box_object_with_no_bound_not_ok<'a>() { - assert_send::>(); //~ ERROR the trait `core::kinds::Send` is not implemented + assert_send::>(); //~ ERROR the trait `core::markers::Send` is not implemented } fn object_with_send_bound_ok() { diff --git a/src/test/compile-fail/kindck-send-object1.rs b/src/test/compile-fail/kindck-send-object1.rs index d83a8031c45db..4f1a95859ae6f 100644 --- a/src/test/compile-fail/kindck-send-object1.rs +++ b/src/test/compile-fail/kindck-send-object1.rs @@ -18,7 +18,7 @@ trait Dummy { } // careful with object types, who knows what they close over... fn test51<'a>() { assert_send::<&'a Dummy>(); - //~^ ERROR the trait `core::kinds::Send` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented } fn test52<'a>() { assert_send::<&'a (Dummy+Send)>(); @@ -37,7 +37,7 @@ fn test61() { // them not ok fn test_71<'a>() { assert_send::>(); - //~^ ERROR the trait `core::kinds::Send` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented } fn main() { } diff --git a/src/test/compile-fail/kindck-send-object2.rs b/src/test/compile-fail/kindck-send-object2.rs index ea8c262830633..06b8cf20258fc 100644 --- a/src/test/compile-fail/kindck-send-object2.rs +++ b/src/test/compile-fail/kindck-send-object2.rs @@ -14,11 +14,11 @@ fn assert_send() { } trait Dummy { } fn test50() { - assert_send::<&'static Dummy>(); //~ ERROR the trait `core::kinds::Send` is not implemented + assert_send::<&'static Dummy>(); //~ ERROR the trait `core::markers::Send` is not implemented } fn test53() { - assert_send::>(); //~ ERROR the trait `core::kinds::Send` is not implemented + assert_send::>(); //~ ERROR the trait `core::markers::Send` is not implemented } // ...unless they are properly bounded diff --git a/src/test/compile-fail/kindck-send-unsafe.rs b/src/test/compile-fail/kindck-send-unsafe.rs index 4e1641025d5ae..0a2f4cbce8505 100644 --- a/src/test/compile-fail/kindck-send-unsafe.rs +++ b/src/test/compile-fail/kindck-send-unsafe.rs @@ -14,7 +14,7 @@ fn assert_send() { } fn test71<'a>() { assert_send::<*mut &'a int>(); - //~^ ERROR the trait `core::kinds::Send` is not implemented for the type + //~^ ERROR the trait `core::markers::Send` is not implemented for the type } fn main() { diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs index 0d5b562e04cdd..3bdc44ec36380 100644 --- a/src/test/compile-fail/lint-dead-code-4.rs +++ b/src/test/compile-fail/lint-dead-code-4.rs @@ -19,7 +19,7 @@ use std::num::Int; struct Foo { x: uint, b: bool, //~ ERROR: struct field is never used - marker: std::kinds::marker::NoCopy + marker: std::markers::NoCopy } fn field_read(f: Foo) -> uint { @@ -59,7 +59,7 @@ fn field_match_in_let(f: Bar) -> bool { } fn main() { - field_read(Foo { x: 1, b: false, marker: std::kinds::marker::NoCopy }); + field_read(Foo { x: 1, b: false, marker: std::markers::NoCopy }); field_match_in_patterns(XYZ::Z); field_match_in_let(Bar { x: 42u, b: true, _guard: () }); let _ = Baz { x: 0 }; diff --git a/src/test/compile-fail/marker-no-copy.rs b/src/test/compile-fail/marker-no-copy.rs index d620c13cc2520..e329cdc32d3de 100644 --- a/src/test/compile-fail/marker-no-copy.rs +++ b/src/test/compile-fail/marker-no-copy.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; fn foo(p: P) { } fn main() { - foo(marker::NoCopy); //~ ERROR the trait `core::kinds::Copy` is not implemented + foo(markers::NoCopy); //~ ERROR the trait `core::markers::Copy` is not implemented } diff --git a/src/test/compile-fail/marker-no-send.rs b/src/test/compile-fail/marker-no-send.rs index 813e2548398b5..dcbe63a417d37 100644 --- a/src/test/compile-fail/marker-no-send.rs +++ b/src/test/compile-fail/marker-no-send.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; fn foo(p: P) { } fn main() { - foo(marker::NoSend); //~ ERROR the trait `core::kinds::Send` is not implemented + foo(markers::NoSend); //~ ERROR the trait `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/marker-no-share.rs b/src/test/compile-fail/marker-no-share.rs index 735e61fa139f0..77d5fc23a3535 100644 --- a/src/test/compile-fail/marker-no-share.rs +++ b/src/test/compile-fail/marker-no-share.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; fn foo(p: P) { } fn main() { - foo(marker::NoSync); //~ ERROR the trait `core::kinds::Sync` is not implemented + foo(markers::NoSync); //~ ERROR the trait `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/mut-not-freeze.rs b/src/test/compile-fail/mut-not-freeze.rs index 95ebb8bd88221..711763c20c6d0 100644 --- a/src/test/compile-fail/mut-not-freeze.rs +++ b/src/test/compile-fail/mut-not-freeze.rs @@ -15,6 +15,6 @@ fn f(_: T) {} fn main() { let x = RefCell::new(0i); f(x); - //~^ ERROR `core::kinds::Sync` is not implemented - //~^^ ERROR `core::kinds::Sync` is not implemented + //~^ ERROR `core::markers::Sync` is not implemented + //~^^ ERROR `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/mutable-enum-indirect.rs b/src/test/compile-fail/mutable-enum-indirect.rs index af9c5256040dd..01c977dc62c89 100644 --- a/src/test/compile-fail/mutable-enum-indirect.rs +++ b/src/test/compile-fail/mutable-enum-indirect.rs @@ -11,13 +11,13 @@ // Tests that an `&` pointer to something inherently mutable is itself // to be considered mutable. -use std::kinds::marker; +use std::markers; -enum Foo { A(marker::NoSync) } +enum Foo { A(markers::NoSync) } fn bar(_: T) {} fn main() { - let x = Foo::A(marker::NoSync); - bar(&x); //~ ERROR the trait `core::kinds::Sync` is not implemented + let x = Foo::A(markers::NoSync); + bar(&x); //~ ERROR the trait `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs index 9e56b27a05b6b..66082d4654932 100644 --- a/src/test/compile-fail/no-send-res-ports.rs +++ b/src/test/compile-fail/no-send-res-ports.rs @@ -36,8 +36,8 @@ fn main() { let x = foo(Port(Rc::new(()))); Thread::spawn(move|| { - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented let y = x; println!("{}", y); }); diff --git a/src/test/compile-fail/no_send-enum.rs b/src/test/compile-fail/no_send-enum.rs index 8b409cfe89dd8..2a0ffd932085a 100644 --- a/src/test/compile-fail/no_send-enum.rs +++ b/src/test/compile-fail/no_send-enum.rs @@ -8,16 +8,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; enum Foo { - A(marker::NoSend) + A(markers::NoSend) } fn bar(_: T) {} fn main() { - let x = Foo::A(marker::NoSend); + let x = Foo::A(markers::NoSend); bar(x); - //~^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/no_send-rc.rs b/src/test/compile-fail/no_send-rc.rs index 004921b1db0d2..e604fd9f838f7 100644 --- a/src/test/compile-fail/no_send-rc.rs +++ b/src/test/compile-fail/no_send-rc.rs @@ -15,6 +15,6 @@ fn bar(_: T) {} fn main() { let x = Rc::new(5i); bar(x); - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/no_send-struct.rs b/src/test/compile-fail/no_send-struct.rs index 6e84578e92e3b..7e2f7c55bd272 100644 --- a/src/test/compile-fail/no_send-struct.rs +++ b/src/test/compile-fail/no_send-struct.rs @@ -8,17 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; struct Foo { a: int, - ns: marker::NoSend + ns: markers::NoSend } fn bar(_: T) {} fn main() { - let x = Foo { a: 5, ns: marker::NoSend }; + let x = Foo { a: 5, ns: markers::NoSend }; bar(x); - //~^ ERROR the trait `core::kinds::Send` is not implemented + //~^ ERROR the trait `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/no_share-enum.rs b/src/test/compile-fail/no_share-enum.rs index cb8ecd7259bb7..aeaa56c35a83f 100644 --- a/src/test/compile-fail/no_share-enum.rs +++ b/src/test/compile-fail/no_share-enum.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; -enum Foo { A(marker::NoSync) } +enum Foo { A(markers::NoSync) } fn bar(_: T) {} fn main() { - let x = Foo::A(marker::NoSync); + let x = Foo::A(markers::NoSync); bar(x); - //~^ ERROR the trait `core::kinds::Sync` is not implemented + //~^ ERROR the trait `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/no_share-rc.rs b/src/test/compile-fail/no_share-rc.rs index ac3b456def526..66e8571527d03 100644 --- a/src/test/compile-fail/no_share-rc.rs +++ b/src/test/compile-fail/no_share-rc.rs @@ -16,6 +16,6 @@ fn bar(_: T) {} fn main() { let x = Rc::new(RefCell::new(5i)); bar(x); - //~^ ERROR the trait `core::kinds::Sync` is not implemented - //~^^ ERROR the trait `core::kinds::Sync` is not implemented + //~^ ERROR the trait `core::markers::Sync` is not implemented + //~^^ ERROR the trait `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/no_share-struct.rs b/src/test/compile-fail/no_share-struct.rs index 1379a9f7382b0..ee6a29d31769a 100644 --- a/src/test/compile-fail/no_share-struct.rs +++ b/src/test/compile-fail/no_share-struct.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; -struct Foo { a: int, m: marker::NoSync } +struct Foo { a: int, m: markers::NoSync } fn bar(_: T) {} fn main() { - let x = Foo { a: 5, m: marker::NoSync }; + let x = Foo { a: 5, m: markers::NoSync }; bar(x); - //~^ ERROR the trait `core::kinds::Sync` is not implemented + //~^ ERROR the trait `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/opt-out-copy-bad.rs b/src/test/compile-fail/opt-out-copy-bad.rs index 4aae8fa87daff..f949e89fcac08 100644 --- a/src/test/compile-fail/opt-out-copy-bad.rs +++ b/src/test/compile-fail/opt-out-copy-bad.rs @@ -30,7 +30,7 @@ impl Copy for IWantToCopyThis {} enum CantCopyThisEither { A, - B(::std::kinds::marker::NoCopy), + B(::std::markers::NoCopy), } enum IWantToCopyThisToo { diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs index 4af748661fd12..b05117a71856c 100644 --- a/src/test/compile-fail/range-1.rs +++ b/src/test/compile-fail/range-1.rs @@ -23,5 +23,5 @@ pub fn main() { // Unsized type. let arr: &[_] = &[1u, 2, 3]; let range = (*arr)..; - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } diff --git a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs index 4dd028b788459..d8bad0f910321 100644 --- a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs +++ b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs @@ -14,13 +14,13 @@ // Note: see variance-regions-*.rs for the tests that check that the // variance inference works in the first place. -use std::kinds::marker; +use std::markers; // This is contravariant with respect to 'a, meaning that // Contravariant<'foo> <: Contravariant<'static> because // 'foo <= 'static struct Contravariant<'a> { - marker: marker::ContravariantLifetime<'a> + marker: markers::ContravariantLifetime<'a> } fn use_<'short,'long>(c: Contravariant<'short>, diff --git a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs index 93c06aecd30ec..58c1f0c4721a0 100644 --- a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs +++ b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs @@ -14,10 +14,10 @@ // Note: see variance-regions-*.rs for the tests that check that the // variance inference works in the first place. -use std::kinds::marker; +use std::markers; struct Covariant<'a> { - marker: marker::CovariantLifetime<'a> + marker: markers::CovariantLifetime<'a> } fn use_<'short,'long>(c: Covariant<'long>, diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs index ad5ad143b15bc..d3d6aa06cdba4 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; struct invariant<'a> { - marker: marker::InvariantLifetime<'a> + marker: markers::InvariantLifetime<'a> } fn to_same_lifetime<'r>(bi: invariant<'r>) { diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs index d3126cf44d1b1..d8a183c0e469b 100644 --- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs +++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs @@ -25,5 +25,5 @@ impl Drop for Foo { fn main() { let a = Foo { x: 3 }; let _ = [ a; 5 ]; - //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `Foo` + //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `Foo` } diff --git a/src/test/compile-fail/static-items-cant-move.rs b/src/test/compile-fail/static-items-cant-move.rs index 28e73f74ff3fc..e0f241f87a76b 100644 --- a/src/test/compile-fail/static-items-cant-move.rs +++ b/src/test/compile-fail/static-items-cant-move.rs @@ -10,14 +10,14 @@ // Verifies that static items can't be moved -use std::kinds::marker; +use std::markers; struct Foo { foo: int, - nocopy: marker::NoCopy + nocopy: markers::NoCopy } -static BAR: Foo = Foo{foo: 5, nocopy: marker::NoCopy}; +static BAR: Foo = Foo{foo: 5, nocopy: markers::NoCopy}; fn test(f: Foo) { diff --git a/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs b/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs index e6dc712137f42..186f5f91eeeec 100644 --- a/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs +++ b/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::Send; +use std::markers::Send; struct TestType; diff --git a/src/test/compile-fail/syntax-trait-polarity.rs b/src/test/compile-fail/syntax-trait-polarity.rs index 3c84bc26298fd..bdfadcad2bf94 100644 --- a/src/test/compile-fail/syntax-trait-polarity.rs +++ b/src/test/compile-fail/syntax-trait-polarity.rs @@ -10,7 +10,7 @@ #![feature(optin_builtin_traits)] -use std::kinds::Send; +use std::markers::Send; struct TestType; diff --git a/src/test/compile-fail/task-rng-isnt-sendable.rs b/src/test/compile-fail/task-rng-isnt-sendable.rs index f673c3b797809..5bc96cae0bbea 100644 --- a/src/test/compile-fail/task-rng-isnt-sendable.rs +++ b/src/test/compile-fail/task-rng-isnt-sendable.rs @@ -16,6 +16,6 @@ fn test_send() {} pub fn main() { test_send::(); - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs index 85a2761172d61..f569bed126d45 100644 --- a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs +++ b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs @@ -14,7 +14,7 @@ trait Foo { // This should emit the less confusing error, not the more confusing one. fn foo(_x: Foo + Send) { - //~^ERROR the trait `core::kinds::Sized` is not implemented + //~^ERROR the trait `core::markers::Sized` is not implemented } fn main() { } diff --git a/src/test/compile-fail/typeck-unsafe-always-share.rs b/src/test/compile-fail/typeck-unsafe-always-share.rs index a7911eb791eb2..d3199ff982e00 100644 --- a/src/test/compile-fail/typeck-unsafe-always-share.rs +++ b/src/test/compile-fail/typeck-unsafe-always-share.rs @@ -13,14 +13,14 @@ // ignore-tidy-linelength use std::cell::UnsafeCell; -use std::kinds::marker; +use std::markers; struct MySync { u: UnsafeCell } struct NoSync { - m: marker::NoSync + m: markers::NoSync } fn test(s: T){ @@ -30,17 +30,17 @@ fn test(s: T){ fn main() { let us = UnsafeCell::new(MySync{u: UnsafeCell::new(0i)}); test(us); - //~^ ERROR `core::kinds::Sync` is not implemented + //~^ ERROR `core::markers::Sync` is not implemented - let uns = UnsafeCell::new(NoSync{m: marker::NoSync}); + let uns = UnsafeCell::new(NoSync{m: markers::NoSync}); test(uns); - //~^ ERROR `core::kinds::Sync` is not implemented + //~^ ERROR `core::markers::Sync` is not implemented let ms = MySync{u: uns}; test(ms); - //~^ ERROR `core::kinds::Sync` is not implemented + //~^ ERROR `core::markers::Sync` is not implemented - let ns = NoSync{m: marker::NoSync}; + let ns = NoSync{m: markers::NoSync}; test(ns); - //~^ ERROR `core::kinds::Sync` is not implemented + //~^ ERROR `core::markers::Sync` is not implemented } diff --git a/src/test/compile-fail/unboxed-closure-sugar-region.rs b/src/test/compile-fail/unboxed-closure-sugar-region.rs index 5ace9e115ec78..ee7d2cc168c0a 100644 --- a/src/test/compile-fail/unboxed-closure-sugar-region.rs +++ b/src/test/compile-fail/unboxed-closure-sugar-region.rs @@ -15,7 +15,7 @@ #![feature(unboxed_closures)] #![allow(dead_code)] -use std::kinds::marker; +use std::markers; trait Foo<'a,T,U> { fn dummy(&'a self) -> &'a (T,U); diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs index 48d5028f4357d..98d8b2d36cd6e 100644 --- a/src/test/compile-fail/unique-unique-kind.rs +++ b/src/test/compile-fail/unique-unique-kind.rs @@ -17,6 +17,6 @@ fn f(_i: T) { fn main() { let i = box Rc::new(100i); f(i); - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented } diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index 993df8e59f3e0..6398623e75b87 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -30,7 +30,7 @@ fn foo(i:int, j: Rc) -> foo { fn main() { let cat = "kitty".to_string(); let (tx, _) = channel(); - //~^ ERROR `core::kinds::Send` is not implemented - //~^^ ERROR `core::kinds::Send` is not implemented + //~^ ERROR `core::markers::Send` is not implemented + //~^^ ERROR `core::markers::Send` is not implemented tx.send(foo(42, Rc::new(cat))); } diff --git a/src/test/compile-fail/unsized-bare-typaram.rs b/src/test/compile-fail/unsized-bare-typaram.rs index 2de490e018b44..b6078cd3af474 100644 --- a/src/test/compile-fail/unsized-bare-typaram.rs +++ b/src/test/compile-fail/unsized-bare-typaram.rs @@ -9,5 +9,5 @@ // except according to those terms. fn bar() { } -fn foo() { bar::() } //~ ERROR the trait `core::kinds::Sized` is not implemented +fn foo() { bar::() } //~ ERROR the trait `core::markers::Sized` is not implemented fn main() { } diff --git a/src/test/compile-fail/unsized-enum.rs b/src/test/compile-fail/unsized-enum.rs index aea236c926815..a78ffb1340892 100644 --- a/src/test/compile-fail/unsized-enum.rs +++ b/src/test/compile-fail/unsized-enum.rs @@ -15,14 +15,14 @@ fn not_sized() { } enum Foo { FooSome(U), FooNone } fn foo1() { not_sized::>() } // Hunky dory. fn foo2() { not_sized::>() } -//~^ ERROR the trait `core::kinds::Sized` is not implemented +//~^ ERROR the trait `core::markers::Sized` is not implemented // // Not OK: `T` is not sized. enum Bar { BarSome(U), BarNone } fn bar1() { not_sized::>() } fn bar2() { is_sized::>() } -//~^ ERROR the trait `core::kinds::Sized` is not implemented +//~^ ERROR the trait `core::markers::Sized` is not implemented // // Not OK: `Bar` is not sized, but it should be. diff --git a/src/test/compile-fail/unsized-struct.rs b/src/test/compile-fail/unsized-struct.rs index 89c711036977a..c681267915528 100644 --- a/src/test/compile-fail/unsized-struct.rs +++ b/src/test/compile-fail/unsized-struct.rs @@ -15,14 +15,14 @@ fn not_sized() { } struct Foo { data: T } fn foo1() { not_sized::>() } // Hunky dory. fn foo2() { not_sized::>() } -//~^ ERROR the trait `core::kinds::Sized` is not implemented +//~^ ERROR the trait `core::markers::Sized` is not implemented // // Not OK: `T` is not sized. struct Bar { data: T } fn bar1() { not_sized::>() } fn bar2() { is_sized::>() } -//~^ ERROR the trait `core::kinds::Sized` is not implemented +//~^ ERROR the trait `core::markers::Sized` is not implemented // // Not OK: `Bar` is not sized, but it should be. diff --git a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs index 7ae74fc2600c8..9a29775f7c90c 100644 --- a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs +++ b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs @@ -15,7 +15,7 @@ trait T2 { } struct S4; impl T2 for S4 { - //~^ ERROR `core::kinds::Sized` is not implemented for the type `X` + //~^ ERROR `core::markers::Sized` is not implemented for the type `X` } fn main() { } diff --git a/src/test/compile-fail/unsized3.rs b/src/test/compile-fail/unsized3.rs index 9b7d10b0d0f76..7e4a1d135570b 100644 --- a/src/test/compile-fail/unsized3.rs +++ b/src/test/compile-fail/unsized3.rs @@ -14,7 +14,7 @@ // Unbounded. fn f1(x: &X) { f2::(x); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } fn f2(x: &X) { } @@ -23,7 +23,7 @@ fn f2(x: &X) { trait T {} fn f3(x: &X) { f4::(x); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } fn f4(x: &X) { } @@ -37,7 +37,7 @@ fn f5(x: &Y) {} fn f6(x: &X) {} fn f7(x1: &E, x2: &E) { f5(x1); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented f6(x2); // ok } @@ -49,19 +49,19 @@ struct S { fn f8(x1: &S, x2: &S) { f5(x1); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented f6(x2); // ok } // Test some tuples. fn f9(x1: Box>, x2: Box>) { f5(&(*x1, 34i)); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } fn f10(x1: Box>, x2: Box>) { f5(&(32i, *x2)); - //~^ ERROR the trait `core::kinds::Sized` is not implemented + //~^ ERROR the trait `core::markers::Sized` is not implemented } pub fn main() { diff --git a/src/test/compile-fail/unsized5.rs b/src/test/compile-fail/unsized5.rs index f7477d746fae4..a714b7d92383b 100644 --- a/src/test/compile-fail/unsized5.rs +++ b/src/test/compile-fail/unsized5.rs @@ -8,30 +8,30 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test `Sized?` types not allowed in fields (except the last one). +// Test `?Sized` types not allowed in fields (except the last one). struct S1 { - f1: X, //~ ERROR `core::kinds::Sized` is not implemented + f1: X, //~ ERROR `core::markers::Sized` is not implemented f2: int, } struct S2 { f: int, - g: X, //~ ERROR `core::kinds::Sized` is not implemented + g: X, //~ ERROR `core::markers::Sized` is not implemented h: int, } struct S3 { - f: str, //~ ERROR `core::kinds::Sized` is not implemented + f: str, //~ ERROR `core::markers::Sized` is not implemented g: [uint] } struct S4 { - f: str, //~ ERROR `core::kinds::Sized` is not implemented + f: str, //~ ERROR `core::markers::Sized` is not implemented g: uint } enum E { - V1(X, int), //~ERROR `core::kinds::Sized` is not implemented + V1(X, int), //~ERROR `core::markers::Sized` is not implemented } enum F { - V2{f1: X, f: int}, //~ERROR `core::kinds::Sized` is not implemented + V2{f1: X, f: int}, //~ERROR `core::markers::Sized` is not implemented } pub fn main() { diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs index b4f0a4912cf30..d3b03493fdcb3 100644 --- a/src/test/compile-fail/unsized6.rs +++ b/src/test/compile-fail/unsized6.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test `Sized?` local variables. +// Test `?Sized` local variables. trait T {} @@ -16,27 +16,27 @@ trait T {} fn f1(x: &X) { let _: X; // <-- this is OK, no bindings created, no initializer. let _: (int, (X, int)); // same - let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented - let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented + let y: X; //~ERROR the trait `core::markers::Sized` is not implemented + let y: (int, (X, int)); //~ERROR the trait `core::markers::Sized` is not implemented } fn f2(x: &X) { - let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented - let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented + let y: X; //~ERROR the trait `core::markers::Sized` is not implemented + let y: (int, (X, int)); //~ERROR the trait `core::markers::Sized` is not implemented } fn f3(x1: Box, x2: Box, x3: Box) { - let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented - let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented - let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented + let y: X = *x1; //~ERROR the trait `core::markers::Sized` is not implemented + let y = *x2; //~ERROR the trait `core::markers::Sized` is not implemented + let (y, z) = (*x3, 4i); //~ERROR the trait `core::markers::Sized` is not implemented } -fn f4(x1: Box, x2: Box, x3: Box) { - let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented - let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented - let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented +fn f4(x1: Box, x2: Box, x3: Box) { + let y: X = *x1; //~ERROR the trait `core::markers::Sized` is not implemented + let y = *x2; //~ERROR the trait `core::markers::Sized` is not implemented + let (y, z) = (*x3, 4i); //~ERROR the trait `core::markers::Sized` is not implemented } -fn g1(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented -fn g2(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented +fn g1(x: X) {} //~ERROR the trait `core::markers::Sized` is not implemented +fn g2(x: X) {} //~ERROR the trait `core::markers::Sized` is not implemented pub fn main() { } diff --git a/src/test/compile-fail/unsized7.rs b/src/test/compile-fail/unsized7.rs index 8a54771112f8e..32daa2a246ed2 100644 --- a/src/test/compile-fail/unsized7.rs +++ b/src/test/compile-fail/unsized7.rs @@ -18,7 +18,7 @@ trait T1 { } struct S3; impl T1 for S3 { - //~^ ERROR `core::kinds::Sized` is not implemented for the type `X` + //~^ ERROR `core::markers::Sized` is not implemented for the type `X` } fn main() { } diff --git a/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs b/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs index 8d72e260a18f7..c584c30448f09 100644 --- a/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs +++ b/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs @@ -21,7 +21,7 @@ impl Foo { fn fails_copy(self) { require_copy(self.x); - //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T` + //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `T` } } diff --git a/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs b/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs index 096b53a1ea624..45df3af08d48a 100644 --- a/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs +++ b/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs @@ -26,7 +26,7 @@ impl Foo for Bar { fn fails_copy(self) { require_copy(self.x); - //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T` + //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `T` } } diff --git a/src/test/run-pass/associated-types-impl-redirect.rs b/src/test/run-pass/associated-types-impl-redirect.rs index 388a2d7344731..d18d6ffd7d06b 100644 --- a/src/test/run-pass/associated-types-impl-redirect.rs +++ b/src/test/run-pass/associated-types-impl-redirect.rs @@ -19,7 +19,7 @@ #![feature(lang_items, unboxed_closures)] #![no_implicit_prelude] -use std::kinds::Sized; +use std::markers::Sized; use std::option::Option::{None, Some, self}; trait Iterator { diff --git a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs index abbe250b6279a..4ebf071cbc151 100644 --- a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs +++ b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs @@ -19,7 +19,7 @@ #![feature(lang_items, unboxed_closures)] #![no_implicit_prelude] -use std::kinds::Sized; +use std::markers::Sized; use std::option::Option::{None, Some, self}; trait Iterator { diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs index 35783ea5899d5..9ec68264076dd 100644 --- a/src/test/run-pass/const-block.rs +++ b/src/test/run-pass/const-block.rs @@ -11,7 +11,7 @@ #![allow(dead_code)] #![allow(unused_unsafe)] -use std::kinds::Sync; +use std::markers::Sync; struct Foo { a: uint, diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs index 14843b30e1c41..5ce8eb64318ee 100644 --- a/src/test/run-pass/fsu-moves-and-copies.rs +++ b/src/test/run-pass/fsu-moves-and-copies.rs @@ -11,7 +11,7 @@ // Issue 4691: Ensure that functional-struct-updates operates // correctly and moves rather than copy when appropriate. -use std::kinds::marker::NoCopy as NP; +use std::markers::NoCopy as NP; struct ncint { np: NP, v: int } fn ncint(v: int) -> ncint { ncint { np: NP, v: v } } diff --git a/src/test/run-pass/hrtb-opt-in-copy.rs b/src/test/run-pass/hrtb-opt-in-copy.rs index 0616a7b21b546..e364cb0c9a2ab 100644 --- a/src/test/run-pass/hrtb-opt-in-copy.rs +++ b/src/test/run-pass/hrtb-opt-in-copy.rs @@ -18,7 +18,7 @@ #![allow(dead_code)] -use std::kinds::marker; +use std::markers; #[derive(Copy)] struct Foo { x: T } @@ -26,7 +26,7 @@ struct Foo { x: T } type Ty<'tcx> = &'tcx TyS<'tcx>; enum TyS<'tcx> { - Boop(marker::InvariantLifetime<'tcx>) + Boop(markers::InvariantLifetime<'tcx>) } enum Bar<'tcx> { diff --git a/src/test/run-pass/issue-17718-static-unsafe-interior.rs b/src/test/run-pass/issue-17718-static-unsafe-interior.rs index 0851f0e367bf8..ac9a70379f8f9 100644 --- a/src/test/run-pass/issue-17718-static-unsafe-interior.rs +++ b/src/test/run-pass/issue-17718-static-unsafe-interior.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::kinds::marker; +use std::markers; use std::cell::UnsafeCell; struct MyUnsafePack(UnsafeCell); diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index f414606340924..435b16998837b 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -23,7 +23,7 @@ pub mod pipes { use std::mem::{replace, swap}; use std::mem; use std::thread::Thread; - use std::kinds::Send; + use std::markers::Send; pub struct Stuff { state: state, diff --git a/src/test/run-pass/method-recursive-blanket-impl.rs b/src/test/run-pass/method-recursive-blanket-impl.rs index e81244d4beabc..279f05ea1c946 100644 --- a/src/test/run-pass/method-recursive-blanket-impl.rs +++ b/src/test/run-pass/method-recursive-blanket-impl.rs @@ -13,7 +13,7 @@ // know not to stop at the blanket, we have to recursively evaluate // the `T:Foo` bound. -use std::kinds::Sized; +use std::markers::Sized; // Note: this must be generic for the problem to show up trait Foo { diff --git a/src/test/run-pass/regions-infer-bivariance.rs b/src/test/run-pass/regions-infer-bivariance.rs index 8b9d6af1017b5..a750b3f4b4e10 100644 --- a/src/test/run-pass/regions-infer-bivariance.rs +++ b/src/test/run-pass/regions-infer-bivariance.rs @@ -11,7 +11,7 @@ // Test that a type whose lifetime parameters is never used is // inferred to be bivariant. -use std::kinds::marker; +use std::markers; struct Bivariant<'a>; diff --git a/src/test/run-pass/syntax-trait-polarity.rs b/src/test/run-pass/syntax-trait-polarity.rs index 021cfedf06f96..244e084e65b82 100644 --- a/src/test/run-pass/syntax-trait-polarity.rs +++ b/src/test/run-pass/syntax-trait-polarity.rs @@ -10,7 +10,7 @@ #![feature(optin_builtin_traits)] -use std::kinds::Send; +use std::markers::Send; struct TestType; From ba2a77b4506ca29105ebd7e257bb2328c2b2b1b3 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Tue, 6 Jan 2015 15:21:06 +1300 Subject: [PATCH 24/49] stabilisation --- src/libcore/markers.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/libcore/markers.rs b/src/libcore/markers.rs index 0663ceb68e69b..45b80593c3cd5 100644 --- a/src/libcore/markers.rs +++ b/src/libcore/markers.rs @@ -29,18 +29,21 @@ use clone::Clone; /// Types able to be transferred across task boundaries. +#[unstable = "will be overhauled with new lifetime rules; see RFC 458"] #[lang="send"] pub unsafe trait Send: 'static { // empty. } /// Types with a constant size known at compile-time. +#[stable] #[lang="sized"] pub trait Sized { // Empty. } /// Types that can be copied by simply copying bits (i.e. `memcpy`). +#[stable] #[lang="copy"] pub trait Copy { // Empty. @@ -91,6 +94,7 @@ pub trait Copy { /// around the value(s) which can be mutated when behind a `&` /// reference; not doing this is undefined behaviour (for example, /// `transmute`-ing from `&T` to `&mut T` is illegal). +#[unstable = "will be overhauled with new lifetime rules; see RFC 458"] #[lang="sync"] pub unsafe trait Sync { // Empty @@ -134,6 +138,7 @@ pub unsafe trait Sync { /// `S` is a subtype of `S` if `T` is a subtype of `U` /// (for example, `S<&'static int>` is a subtype of `S<&'a int>` /// for some lifetime `'a`, but not the other way around). +#[unstable = "likely to change with new variance strategy"] #[lang="covariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] pub struct CovariantType; @@ -182,6 +187,7 @@ impl Clone for CovariantType { /// subtype of `S` if `U` is a subtype of `T`; given that the /// function requires arguments of type `T`, it must also accept /// arguments of type `U`, hence such a conversion is safe. +#[unstable = "likely to change with new variance strategy"] #[lang="contravariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] pub struct ContravariantType; @@ -212,11 +218,14 @@ impl Clone for ContravariantType { /// The type system would infer that `value` is only read here and /// never written, but in fact `Cell` uses unsafe code to achieve /// interior mutability. +#[unstable = "likely to change with new variance strategy"] #[lang="invariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] pub struct InvariantType; +#[unstable = "likely to change with new variance strategy"] impl Copy for InvariantType {} +#[unstable = "likely to change with new variance strategy"] impl Clone for InvariantType { fn clone(&self) -> InvariantType { *self } } @@ -237,6 +246,7 @@ impl Clone for InvariantType { /// /// For more information about variance, refer to this Wikipedia /// article . +#[unstable = "likely to change with new variance strategy"] #[lang="covariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct CovariantLifetime<'a>; @@ -253,6 +263,7 @@ pub struct CovariantLifetime<'a>; /// /// For more information about variance, refer to this Wikipedia /// article . +#[unstable = "likely to change with new variance strategy"] #[lang="contravariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct ContravariantLifetime<'a>; @@ -264,6 +275,7 @@ pub struct ContravariantLifetime<'a>; /// pointer that is actually a pointer into memory with lifetime `'a`, /// and this pointer is itself stored in an inherently mutable /// location (such as a `Cell`). +#[unstable = "likely to change with new variance strategy"] #[lang="invariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct InvariantLifetime<'a>; @@ -272,6 +284,7 @@ pub struct InvariantLifetime<'a>; /// be safely sent between tasks, even if it is owned. This is /// typically embedded in other types, such as `Gc`, to ensure that /// their instances remain thread-local. +#[unstable = "likely to change with new variance strategy"] #[lang="no_send_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct NoSend; @@ -279,6 +292,7 @@ pub struct NoSend; /// A type which is considered "not POD", meaning that it is not /// implicitly copyable. This is typically embedded in other types to /// ensure that they are never copied, even if they lack a destructor. +#[unstable = "likely to change with new variance strategy"] #[lang="no_copy_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] #[allow(missing_copy_implementations)] @@ -287,12 +301,14 @@ pub struct NoCopy; /// A type which is considered "not sync", meaning that /// its contents are not threadsafe, hence they cannot be /// shared between tasks. +#[unstable = "likely to change with new variance strategy"] #[lang="no_sync_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct NoSync; /// A type which is considered managed by the GC. This is typically /// embedded in other types. +#[unstable = "likely to change with new variance strategy"] #[lang="managed_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] #[allow(missing_copy_implementations)] From 91ba66fa99830d4963d6adb47439b86253bf5a4c Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Tue, 6 Jan 2015 16:06:23 +1300 Subject: [PATCH 25/49] Review changes --- src/libcore/markers.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/libcore/markers.rs b/src/libcore/markers.rs index 45b80593c3cd5..f218eaceee2de 100644 --- a/src/libcore/markers.rs +++ b/src/libcore/markers.rs @@ -23,11 +23,10 @@ //! implemented using unsafe code. In that case, you may want to embed //! some of the marker types below into your type. - +#![stable] use clone::Clone; - /// Types able to be transferred across task boundaries. #[unstable = "will be overhauled with new lifetime rules; see RFC 458"] #[lang="send"] From 918255ef8c3c21b2009204c3019239f8dc9f46bf Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Wed, 31 Dec 2014 20:20:40 +1300 Subject: [PATCH 26/49] Impls using the new scheme for slicing --- src/libcollections/string.rs | 24 +++-- src/libcollections/vec.rs | 55 +++++++--- src/libcore/ops.rs | 101 ------------------ src/libcore/prelude.rs | 2 +- src/libcore/slice.rs | 200 ++++++++++++++++++++++------------- src/libcore/str/mod.rs | 24 +++-- 6 files changed, 197 insertions(+), 209 deletions(-) diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 0bf311e4d3f6e..b05b5e276e867 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -818,25 +818,31 @@ impl<'a> Add<&'a str> for String { } } -impl ops::Slice for String { +impl ops::Index, str> for String { #[inline] - fn as_slice_<'a>(&'a self) -> &'a str { - unsafe { mem::transmute(self.vec.as_slice()) } + fn index(&self, &index: &ops::Range) -> &str { + self[][*index] } +} +impl ops::Index, str> for String { #[inline] - fn slice_from_or_fail<'a>(&'a self, from: &uint) -> &'a str { - self[][*from..] + fn index(&self, &index: &ops::RangeTo) -> &str { + self[][*index] } +} +impl ops::Index, str> for String { #[inline] - fn slice_to_or_fail<'a>(&'a self, to: &uint) -> &'a str { - self[][..*to] + fn index(&self, &index: &ops::RangeFrom) -> &str { + self[][*index] } +} +impl ops::Index, str> for String { #[inline] - fn slice_or_fail<'a>(&'a self, from: &uint, to: &uint) -> &'a str { - self[][*from..*to] + fn index(&self, &index: &ops::FullRange) -> &str { + unsafe { mem::transmute(self.vec.as_slice()) } } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 99231e7253c3c..c057939df2b42 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1211,43 +1211,64 @@ impl IndexMut for Vec { impl ops::Slice for Vec { #[inline] - fn as_slice_<'a>(&'a self) -> &'a [T] { - self.as_slice() + fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T { + &mut self.as_mut_slice()[*index] } +} +impl ops::Index, [T]> for Vec { #[inline] - fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] { - self.as_slice().slice_from_or_fail(start) + fn index(&self, &index: &ops::Range) -> &[T] { + self.as_slice().index(index) } +} +impl ops::Index, [T]> for Vec { #[inline] - fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] { - self.as_slice().slice_to_or_fail(end) + fn index(&self, &index: &ops::RangeTo) -> &[T] { + self.as_slice().index(index) } +} + +impl ops::Index, [T]> for Vec { #[inline] - fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] { - self.as_slice().slice_or_fail(start, end) + fn index(&self, &index: &ops::RangeFrom) -> &[T] { + self.as_slice().index(index) } } -impl ops::SliceMut for Vec { +impl ops::Index, [T]> for Vec { #[inline] - fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] { - self.as_mut_slice() + fn index(&self, &index: &ops::FullRange) -> &[T] { + self.as_slice() } +} +impl ops::IndexMut, [T]> for Vec { #[inline] - fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] { - self.as_mut_slice().slice_from_or_fail_mut(start) + fn index_mut(&mut self, &index: &ops::Range) -> &mut [T] { + self.as_mut_slice().index_mut(index) } +} +impl ops::IndexMut, [T]> for Vec { #[inline] - fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] { - self.as_mut_slice().slice_to_or_fail_mut(end) + fn index_mut(&mut self, &index: &ops::RangeTo) -> &mut [T] { + self.as_mut_slice().index_mut(index) } +} + +impl ops::IndexMut, [T]> for Vec { #[inline] - fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] { - self.as_mut_slice().slice_or_fail_mut(start, end) + fn index_mut(&mut self, &index: &ops::RangeFrom) -> &mut [T] { + self.as_mut_slice().index_mut(index) + } +} + +impl ops::IndexMut, [T]> for Vec { + #[inline] + fn index_mut(&mut self, &index: &ops::FullRange) -> &mut [T] { + self.as_mut_slice() } } diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 97d94e73bb33a..2a7e6eb47955d 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -846,105 +846,6 @@ pub trait IndexMut { fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Self::Output; } -/// The `Slice` trait is used to specify the functionality of slicing operations -/// like `arr[from..to]` when used in an immutable context. -/// -/// # Example -/// -/// A trivial implementation of `Slice`. When `Foo[..Foo]` happens, it ends up -/// calling `slice_to`, and therefore, `main` prints `Slicing!`. -/// -/// ```ignore -/// use std::ops::Slice; -/// -/// #[derive(Copy)] -/// struct Foo; -/// -/// impl Slice for Foo { -/// fn as_slice_<'a>(&'a self) -> &'a Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo { -/// println!("Slicing!"); -/// self -/// } -/// } -/// -/// fn main() { -/// Foo[..Foo]; -/// } -/// ``` -#[lang="slice"] -pub trait Slice { - /// The method for the slicing operation foo[] - fn as_slice_<'a>(&'a self) -> &'a Result; - /// The method for the slicing operation foo[from..] - fn slice_from_or_fail<'a>(&'a self, from: &Idx) -> &'a Result; - /// The method for the slicing operation foo[..to] - fn slice_to_or_fail<'a>(&'a self, to: &Idx) -> &'a Result; - /// The method for the slicing operation foo[from..to] - fn slice_or_fail<'a>(&'a self, from: &Idx, to: &Idx) -> &'a Result; -} - -/// The `SliceMut` trait is used to specify the functionality of slicing -/// operations like `arr[from..to]`, when used in a mutable context. -/// -/// # Example -/// -/// A trivial implementation of `SliceMut`. When `Foo[Foo..]` happens, it ends up -/// calling `slice_from_mut`, and therefore, `main` prints `Slicing!`. -/// -/// ```ignore -/// use std::ops::SliceMut; -/// -/// #[derive(Copy)] -/// struct Foo; -/// -/// impl SliceMut for Foo { -/// fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo { -/// println!("Slicing!"); -/// self -/// } -/// fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo { -/// println!("Slicing!"); -/// self -/// } -/// } -/// -/// pub fn main() { -/// Foo[mut Foo..]; -/// } -/// ``` -#[lang="slice_mut"] -pub trait SliceMut { - /// The method for the slicing operation foo[] - fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result; - /// The method for the slicing operation foo[from..] - fn slice_from_or_fail_mut<'a>(&'a mut self, from: &Idx) -> &'a mut Result; - /// The method for the slicing operation foo[..to] - fn slice_to_or_fail_mut<'a>(&'a mut self, to: &Idx) -> &'a mut Result; - /// The method for the slicing operation foo[from..to] - fn slice_or_fail_mut<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result; -} - - /// An unbounded range. #[derive(Copy)] #[lang="full_range"] @@ -962,8 +863,6 @@ pub struct Range { pub end: Idx, } -// FIXME(#19391) needs a snapshot -//impl> Iterator for Range { #[unstable = "API still in development"] impl Iterator for Range { type Item = Idx; diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index e88cb73c8a9b7..a560b68db01fa 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -30,7 +30,7 @@ // Reexported core operators pub use kinds::{Copy, Send, Sized, Sync}; -pub use ops::{Drop, Fn, FnMut, FnOnce}; +pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange}; // Reexported functions pub use iter::range; diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 093ed0b242f5f..369652b215f24 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -292,17 +292,17 @@ impl SliceExt for [T] { fn as_mut_slice(&mut self) -> &mut [T] { self } fn slice_mut(&mut self, start: uint, end: uint) -> &mut [T] { - ops::SliceMut::slice_or_fail_mut(self, &start, &end) + ops::IndexMut::index_mut(self, &ops::Range { start: start, end: end } ) } #[inline] fn slice_from_mut(&mut self, start: uint) -> &mut [T] { - ops::SliceMut::slice_from_or_fail_mut(self, &start) + ops::IndexMut::index_mut(self, &ops::RangeFrom { start: start } ) } #[inline] fn slice_to_mut(&mut self, end: uint) -> &mut [T] { - ops::SliceMut::slice_to_or_fail_mut(self, &end) + ops::IndexMut::index_mut(self, &ops::RangeTo { end: end } ) } #[inline] @@ -310,8 +310,8 @@ impl SliceExt for [T] { unsafe { let self2: &mut [T] = mem::transmute_copy(&self); - (ops::SliceMut::slice_to_or_fail_mut(self, &mid), - ops::SliceMut::slice_from_or_fail_mut(self2, &mid)) + (ops::IndexMut::index_mut(self, &ops::RangeTo { end: mid } ), + ops::IndexMut::index_mut(self2, &ops::RangeFrom { start: mid } )) } } @@ -551,63 +551,78 @@ impl ops::IndexMut for [T] { } } -impl ops::Slice for [T] { +impl ops::Index, [T]> for [T] { #[inline] - fn as_slice_<'a>(&'a self) -> &'a [T] { - self + fn index(&self, &index: &ops::Range) -> &[T] { + assert!(index.start <= index.end); + assert!(index.end <= self.len()); + unsafe { + transmute(RawSlice { + data: self.as_ptr().offset(index.start as int), + len: index.end - index.start + }) + } + } +} + +impl ops::Index, [T]> for [T] { + #[inline] + fn index(&self, &index: &ops::RangeTo) -> &[T] { + self.index(&ops::Range{ start: 0, end: index.end }) } +} +impl ops::Index, [T]> for [T] { #[inline] - fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] { - self.slice_or_fail(start, &self.len()) + fn index(&self, &index: &ops::RangeFrom) -> &[T] { + self.index(&ops::Range{ start: index.start, end: self.len() }) } +} +impl ops::Index for [T] { #[inline] - fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] { - self.slice_or_fail(&0, end) + fn index(&self, &index: &ops::FullRange) -> &[T] { + self } +} + +impl ops::IndexMut, [T]> for [T] { #[inline] - fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] { - assert!(*start <= *end); - assert!(*end <= self.len()); + fn index_mut(&mut self, &index: &ops::Range) -> &mut [T] { + assert!(index.start <= index.end); + assert!(index.end <= self.len()); unsafe { transmute(RawSlice { - data: self.as_ptr().offset(*start as int), - len: (*end - *start) + data: self.as_ptr().offset(index.start as int), + len: index.end - index.start }) } } } -impl ops::SliceMut for [T] { +impl ops::IndexMut, [T]> for [T] { #[inline] - fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] { - self + fn index_mut(&mut self, &index: &ops::RangeTo) -> &mut [T] { + self.index_mut(&ops::Range{ start: 0, end: index.end }) } +} +impl ops::IndexMut, [T]> for [T] { #[inline] - fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] { - let len = &self.len(); - self.slice_or_fail_mut(start, len) + fn index_mut(&mut self, &index: &ops::RangeFrom) -> &mut [T] { + let len = self.len(); + self.index_mut(&ops::Range{ start: index.start, end: len }) } +} +impl ops::IndexMut for [T] { #[inline] - fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] { - self.slice_or_fail_mut(&0, end) - } - #[inline] - fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] { - assert!(*start <= *end); - assert!(*end <= self.len()); - unsafe { - transmute(RawSlice { - data: self.as_ptr().offset(*start as int), - len: (*end - *start) - }) - } + fn index_mut(&mut self, &index: &ops::FullRange) -> &mut [T] { + self } } + //////////////////////////////////////////////////////////////////////////////// // Common traits //////////////////////////////////////////////////////////////////////////////// @@ -738,24 +753,38 @@ pub struct Iter<'a, T: 'a> { } #[experimental] -impl<'a, T> ops::Slice for Iter<'a, T> { - fn as_slice_(&self) -> &[T] { - self.as_slice() +impl<'a, T> ops::Index, [T]> for Iter<'a, T> { + #[inline] + fn index(&self, index: &ops::Range) -> &[T] { + self.as_slice().index(index) } - fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice().slice_from_or_fail(from) +} + +#[experimental] +impl<'a, T> ops::Index, [T]> for Iter<'a, T> { + #[inline] + fn index(&self, index: &ops::RangeTo) -> &[T] { + self.as_slice().index(index) } - fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice().slice_to_or_fail(to) +} + +#[experimental] +impl<'a, T> ops::Index, [T]> for Iter<'a, T> { + #[inline] + fn index(&self, index: &ops::RangeFrom) -> &[T] { + self.as_slice().index(index) } - fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice().slice_or_fail(from, to) +} + +#[experimental] +impl<'a, T> ops::Index for Iter<'a, T> { + #[inline] + fn index(&self, index: &ops::FullRange) -> &[T] { + self.as_slice() } } + impl<'a, T> Iter<'a, T> { /// View the underlying data as a subslice of the original data. /// @@ -813,43 +842,70 @@ pub struct IterMut<'a, T: 'a> { } #[experimental] -impl<'a, T> ops::Slice for IterMut<'a, T> { - fn as_slice_<'b>(&'b self) -> &'b [T] { - make_slice!(T -> &'b [T]: self.ptr, self.end) +impl<'a, T> ops::Index, [T]> for IterMut<'a, T> { + #[inline] + fn index(&self, index: &ops::Range) -> &[T] { + self.index(&ops::FullRange).index(index) } - fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice_().slice_from_or_fail(from) +} + +#[experimental] +impl<'a, T> ops::Index, [T]> for IterMut<'a, T> { + #[inline] + fn index(&self, index: &ops::RangeTo) -> &[T] { + self.index(&ops::FullRange).index(index) } - fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice_().slice_to_or_fail(to) +} + +#[experimental] +impl<'a, T> ops::Index, [T]> for IterMut<'a, T> { + #[inline] + fn index(&self, index: &ops::RangeFrom) -> &[T] { + self.index(&ops::FullRange).index(index) } - fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] { - use ops::Slice; - self.as_slice_().slice_or_fail(from, to) +} + +#[experimental] +impl<'a, T> ops::Index for IterMut<'a, T> { + #[inline] + fn index(&self, index: &ops::FullRange) -> &[T] { + make_slice!(T -> &[T]: self.ptr, self.end) } } #[experimental] -impl<'a, T> ops::SliceMut for IterMut<'a, T> { - fn as_mut_slice_<'b>(&'b mut self) -> &'b mut [T] { - make_slice!(T -> &'b mut [T]: self.ptr, self.end) +impl<'a, T> ops::IndexMut, [T]> for IterMut<'a, T> { + #[inline] + fn index_mut(&mut self, index: &ops::Range) -> &mut [T] { + self.index_mut(&ops::FullRange).index_mut(index) } - fn slice_from_or_fail_mut<'b>(&'b mut self, from: &uint) -> &'b mut [T] { - use ops::SliceMut; - self.as_mut_slice_().slice_from_or_fail_mut(from) +} + +#[experimental] +impl<'a, T> ops::IndexMut, [T]> for IterMut<'a, T> { + #[inline] + fn index_mut(&mut self, index: &ops::RangeTo) -> &mut [T] { + self.index_mut(&ops::FullRange).index_mut(index) } - fn slice_to_or_fail_mut<'b>(&'b mut self, to: &uint) -> &'b mut [T] { - use ops::SliceMut; - self.as_mut_slice_().slice_to_or_fail_mut(to) +} + +#[experimental] +impl<'a, T> ops::IndexMut, [T]> for IterMut<'a, T> { + #[inline] + fn index_mut(&mut self, index: &ops::RangeFrom) -> &mut [T] { + self.index_mut(&ops::FullRange).index_mut(index) } - fn slice_or_fail_mut<'b>(&'b mut self, from: &uint, to: &uint) -> &'b mut [T] { - use ops::SliceMut; - self.as_mut_slice_().slice_or_fail_mut(from, to) +} + +#[experimental] +impl<'a, T> ops::IndexMut for IterMut<'a, T> { + #[inline] + fn index_mut(&mut self, index: &ops::FullRange) -> &mut [T] { + make_slice!(T -> &mut [T]: self.ptr, self.end) } } + impl<'a, T> IterMut<'a, T> { /// View the underlying data as a subslice of the original data. /// diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a39787b8207b5..a28e56144177e 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -1119,25 +1119,31 @@ mod traits { } } - impl ops::Slice for str { + impl ops::Index, str> for str { #[inline] - fn as_slice_<'a>(&'a self) -> &'a str { - self + fn index(&self, &index: &ops::Range) -> &str { + self.slice(index.start, index.end) } + } + impl ops::Index, str> for str { #[inline] - fn slice_from_or_fail<'a>(&'a self, from: &uint) -> &'a str { - self.slice_from(*from) + fn index(&self, &index: &ops::RangeTo) -> &str { + self.slice_to(index.end) } + } + impl ops::Index, str> for str { #[inline] - fn slice_to_or_fail<'a>(&'a self, to: &uint) -> &'a str { - self.slice_to(*to) + fn index(&self, &index: &ops::RangeFrom) -> &str { + self.slice_from(index.start) } + } + impl ops::Index for str { #[inline] - fn slice_or_fail<'a>(&'a self, from: &uint, to: &uint) -> &'a str { - self.slice(*from, *to) + fn index(&self, &index: &ops::FullRange) -> &str { + self } } } From f7ff37e4c52a1d6562635fcd5bab6309cf75ea08 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Fri, 2 Jan 2015 13:56:28 +1300 Subject: [PATCH 27/49] Replace full slice notation with index calls --- src/compiletest/runtest.rs | 4 +- src/libcollections/bit.rs | 2 +- src/libcollections/ring_buf.rs | 2 +- src/libcollections/slice.rs | 26 +-- src/libcollections/str.rs | 106 +++++----- src/libcollections/string.rs | 38 ++-- src/libcollections/vec.rs | 35 ++-- src/libcollections/vec_map.rs | 3 +- src/libcore/array.rs | 28 +-- src/libcore/fmt/float.rs | 4 +- src/libcore/fmt/mod.rs | 6 +- src/libcore/fmt/num.rs | 3 +- src/libcore/num/mod.rs | 4 +- src/libcore/slice.rs | 46 +++-- src/libcore/str/mod.rs | 20 +- src/libcoretest/char.rs | 4 +- src/libcoretest/iter.rs | 28 +-- src/libcoretest/slice.rs | 14 +- src/libfmt_macros/lib.rs | 14 +- src/libgetopts/lib.rs | 69 ++++--- src/libgraphviz/lib.rs | 6 +- src/liblog/lib.rs | 6 +- src/librand/distributions/mod.rs | 6 +- src/librand/distributions/range.rs | 2 +- src/librand/lib.rs | 6 +- src/librbml/io.rs | 2 +- src/librbml/lib.rs | 4 +- src/libregex/compile.rs | 2 +- src/libregex/parse.rs | 57 +++--- src/libregex/re.rs | 18 +- src/libregex/test/matches.rs | 2 +- src/libregex/vm.rs | 5 +- src/librustc/lint/builtin.rs | 44 ++-- src/librustc/lint/context.rs | 56 +++--- src/librustc/metadata/creader.rs | 34 ++-- src/librustc/metadata/csearch.rs | 2 +- src/librustc/metadata/decoder.rs | 6 +- src/librustc/metadata/encoder.rs | 88 ++++---- src/librustc/metadata/loader.rs | 36 ++-- src/librustc/metadata/tydecode.rs | 16 +- src/librustc/middle/astconv_util.rs | 2 +- src/librustc/middle/astencode.rs | 6 +- src/librustc/middle/cfg/construct.rs | 6 +- src/librustc/middle/cfg/graphviz.rs | 4 +- src/librustc/middle/check_loop.rs | 4 +- src/librustc/middle/check_match.rs | 26 +-- src/librustc/middle/check_static.rs | 6 +- src/librustc/middle/check_static_recursion.rs | 2 +- src/librustc/middle/const_eval.rs | 8 +- src/librustc/middle/dataflow.rs | 6 +- src/librustc/middle/dependency_format.rs | 6 +- src/librustc/middle/expr_use_visitor.rs | 4 +- src/librustc/middle/infer/combine.rs | 6 +- src/librustc/middle/infer/error_reporting.rs | 74 +++---- .../middle/infer/higher_ranked/mod.rs | 6 +- src/librustc/middle/infer/mod.rs | 2 +- .../middle/infer/region_inference/mod.rs | 16 +- src/librustc/middle/infer/resolve.rs | 2 +- src/librustc/middle/liveness.rs | 12 +- src/librustc/middle/mem_categorization.rs | 4 +- src/librustc/middle/privacy.rs | 10 +- src/librustc/middle/reachable.rs | 10 +- src/librustc/middle/region.rs | 2 +- src/librustc/middle/resolve_lifetime.rs | 6 +- src/librustc/middle/subst.rs | 4 +- src/librustc/middle/traits/coherence.rs | 2 +- src/librustc/middle/traits/error_reporting.rs | 2 +- src/librustc/middle/traits/fulfill.rs | 2 +- src/librustc/middle/traits/select.rs | 10 +- src/librustc/middle/ty.rs | 74 +++---- src/librustc/plugin/load.rs | 6 +- src/librustc/session/config.rs | 56 +++--- src/librustc/session/mod.rs | 4 +- src/librustc/util/lev_distance.rs | 2 +- src/librustc/util/ppaux.rs | 34 ++-- src/librustc/util/snapshot_vec.rs | 2 +- src/librustc_back/archive.rs | 42 ++-- src/librustc_back/rpath.rs | 16 +- src/librustc_back/sha2.rs | 8 +- src/librustc_back/svh.rs | 4 +- src/librustc_back/target/mod.rs | 10 +- src/librustc_borrowck/borrowck/check_loans.rs | 42 ++-- src/librustc_borrowck/borrowck/doc.rs | 8 +- src/librustc_borrowck/borrowck/fragments.rs | 40 ++-- .../borrowck/gather_loans/mod.rs | 2 +- .../borrowck/gather_loans/move_error.rs | 8 +- src/librustc_borrowck/borrowck/mod.rs | 38 ++-- src/librustc_borrowck/graphviz.rs | 11 +- src/librustc_driver/driver.rs | 30 +-- src/librustc_driver/lib.rs | 16 +- src/librustc_driver/pretty.rs | 18 +- src/librustc_driver/test.rs | 2 +- src/librustc_resolve/build_reduced_graph.rs | 6 +- src/librustc_resolve/lib.rs | 108 +++++----- src/librustc_trans/back/link.rs | 128 ++++++------ src/librustc_trans/back/lto.rs | 30 +-- src/librustc_trans/back/write.rs | 74 +++---- src/librustc_trans/save/mod.rs | 146 +++++++------- src/librustc_trans/save/recorder.rs | 22 +- src/librustc_trans/save/span_utils.rs | 4 +- src/librustc_trans/trans/_match.rs | 46 ++--- src/librustc_trans/trans/adt.rs | 62 +++--- src/librustc_trans/trans/asm.rs | 12 +- src/librustc_trans/trans/base.rs | 104 +++++----- src/librustc_trans/trans/builder.rs | 10 +- src/librustc_trans/trans/cabi.rs | 4 +- src/librustc_trans/trans/cabi_x86_64.rs | 2 +- src/librustc_trans/trans/callee.rs | 14 +- src/librustc_trans/trans/cleanup.rs | 10 +- src/librustc_trans/trans/closure.rs | 13 +- src/librustc_trans/trans/common.rs | 14 +- src/librustc_trans/trans/consts.rs | 42 ++-- src/librustc_trans/trans/context.rs | 8 +- src/librustc_trans/trans/controlflow.rs | 14 +- src/librustc_trans/trans/datum.rs | 2 +- src/librustc_trans/trans/debuginfo.rs | 144 +++++++------- src/librustc_trans/trans/expr.rs | 50 ++--- src/librustc_trans/trans/foreign.rs | 30 +-- src/librustc_trans/trans/glue.rs | 16 +- src/librustc_trans/trans/meth.rs | 16 +- src/librustc_trans/trans/monomorphize.rs | 22 +- src/librustc_trans/trans/type_.rs | 2 +- src/librustc_trans/trans/type_of.rs | 14 +- src/librustc_typeck/astconv.rs | 40 ++-- src/librustc_typeck/check/method/confirm.rs | 4 +- src/librustc_typeck/check/method/mod.rs | 6 +- src/librustc_typeck/check/method/probe.rs | 10 +- src/librustc_typeck/check/mod.rs | 60 +++--- src/librustc_typeck/check/regionck.rs | 14 +- src/librustc_typeck/check/regionmanip.rs | 2 +- src/librustc_typeck/check/vtable.rs | 4 +- src/librustc_typeck/coherence/mod.rs | 6 +- src/librustc_typeck/collect.rs | 28 +-- src/librustc_typeck/lib.rs | 6 +- src/librustc_typeck/variance.rs | 8 +- src/librustdoc/clean/mod.rs | 6 +- src/librustdoc/html/format.rs | 4 +- src/librustdoc/html/highlight.rs | 2 +- src/libserialize/json.rs | 188 +++++++++--------- src/libserialize/serialize.rs | 2 +- src/libstd/failure.rs | 2 +- src/libstd/io/buffered.rs | 18 +- src/libstd/io/comm_adapters.rs | 3 +- src/libstd/io/fs.rs | 2 +- src/libstd/io/mem.rs | 21 +- src/libstd/io/mod.rs | 8 +- src/libstd/io/net/ip.rs | 4 +- src/libstd/io/util.rs | 6 +- src/libstd/path/mod.rs | 13 +- src/libstd/path/posix.rs | 21 +- src/libstd/path/windows.rs | 123 ++++++------ src/libstd/rt/unwind.rs | 2 +- src/libstd/rt/util.rs | 4 +- src/libstd/sync/mpsc/sync.rs | 3 +- src/libstd/sys/common/net.rs | 2 +- src/libstd/sys/windows/os.rs | 2 +- src/libstd/sys/windows/pipe.rs | 2 +- src/libsyntax/ast.rs | 2 +- src/libsyntax/ast_map/mod.rs | 26 +-- src/libsyntax/ast_util.rs | 14 +- src/libsyntax/attr.rs | 12 +- src/libsyntax/codemap.rs | 12 +- src/libsyntax/diagnostic.rs | 40 ++-- src/libsyntax/diagnostics/plugin.rs | 6 +- src/libsyntax/ext/asm.rs | 2 +- src/libsyntax/ext/base.rs | 10 +- src/libsyntax/ext/build.rs | 2 +- src/libsyntax/ext/concat.rs | 8 +- src/libsyntax/ext/concat_idents.rs | 2 +- src/libsyntax/ext/deriving/bounds.rs | 4 +- src/libsyntax/ext/deriving/clone.rs | 6 +- src/libsyntax/ext/deriving/decodable.rs | 2 +- src/libsyntax/ext/deriving/encodable.rs | 2 +- src/libsyntax/ext/deriving/generic/mod.rs | 46 ++--- src/libsyntax/ext/deriving/mod.rs | 2 +- src/libsyntax/ext/deriving/show.rs | 2 +- src/libsyntax/ext/env.rs | 8 +- src/libsyntax/ext/expand.rs | 47 ++--- src/libsyntax/ext/format.rs | 26 +-- src/libsyntax/ext/mtwt.rs | 2 +- src/libsyntax/ext/quote.rs | 6 +- src/libsyntax/ext/source_util.rs | 14 +- src/libsyntax/ext/tt/macro_parser.rs | 26 +-- src/libsyntax/ext/tt/macro_rules.rs | 12 +- src/libsyntax/ext/tt/transcribe.rs | 4 +- src/libsyntax/feature_gate.rs | 10 +- src/libsyntax/parse/attr.rs | 2 +- src/libsyntax/parse/lexer/comments.rs | 16 +- src/libsyntax/parse/lexer/mod.rs | 16 +- src/libsyntax/parse/mod.rs | 46 ++--- src/libsyntax/parse/obsolete.rs | 4 +- src/libsyntax/parse/parser.rs | 158 +++++++-------- src/libsyntax/parse/token.rs | 18 +- src/libsyntax/print/pp.rs | 4 +- src/libsyntax/print/pprust.rs | 160 +++++++-------- src/libsyntax/std_inject.rs | 8 +- src/libsyntax/test.rs | 26 +-- src/libsyntax/util/interner.rs | 12 +- src/libterm/terminfo/mod.rs | 2 +- src/libterm/terminfo/parser/compiled.rs | 6 +- src/libterm/terminfo/searcher.rs | 4 +- src/libtest/lib.rs | 2 +- src/test/bench/shootout-fasta-redux.rs | 4 +- src/test/bench/shootout-k-nucleotide.rs | 4 +- .../borrowck-array-double-move.rs | 2 +- .../borrowck-vec-pattern-move-tail.rs | 2 +- .../packed-struct-generic-transmute.rs | 2 +- src/test/compile-fail/slice-1.rs | 6 +- src/test/compile-fail/slice-2.rs | 8 +- src/test/compile-fail/slice-borrow.rs | 2 +- src/test/compile-fail/slice-mut-2.rs | 2 +- src/test/compile-fail/slice-mut.rs | 2 +- src/test/debuginfo/vec-slices.rs | 2 +- src/test/run-pass/auto-encode.rs | 2 +- .../run-pass/deriving-encodable-decodable.rs | 2 +- src/test/run-pass/issue-15730.rs | 2 +- src/test/run-pass/issue-17503.rs | 6 +- src/test/run-pass/issue-3888-2.rs | 2 +- src/test/run-pass/issue-4464.rs | 2 +- src/test/run-pass/issue-8898.rs | 10 +- src/test/run-pass/repeated-vector-syntax.rs | 2 +- src/test/run-pass/slice-2.rs | 16 +- src/test/run-pass/slice-panic-1.rs | 4 +- src/test/run-pass/slice-panic-2.rs | 2 +- src/test/run-pass/slice.rs | 8 +- 225 files changed, 2166 insertions(+), 2139 deletions(-) diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 875061e69b7a2..684315de00460 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -676,7 +676,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) .unwrap() .to_string(); - script_str.push_str(format!("command script import {}\n", rust_pp_module_abs_path[])[]); + script_str.push_str(format!("command script import {}\n", rust_pp_module_abs_path.index(&FullRange))[]); script_str.push_str("type summary add --no-value "); script_str.push_str("--python-function lldb_rust_formatters.print_val "); script_str.push_str("-x \".*\" --category Rust\n"); @@ -910,7 +910,7 @@ fn check_error_patterns(props: &TestProps, if done { return; } let missing_patterns = - props.error_patterns[next_err_idx..]; + props.error_patterns.index(&(next_err_idx..)); if missing_patterns.len() == 1u { fatal_proc_rec(format!("error pattern '{}' not found!", missing_patterns[0]).as_slice(), diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index c092e000215d3..3d1779445e124 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -330,7 +330,7 @@ impl Bitv { if extra_bytes > 0 { let mut last_word = 0u32; - for (i, &byte) in bytes[complete_words*4..].iter().enumerate() { + for (i, &byte) in bytes.index(&((complete_words*4)..)).iter().enumerate() { last_word |= (reverse_bits(byte) as u32) << (i * 8); } bitv.storage.push(last_word); diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 11775f62b1c54..eff25b6d38500 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -556,7 +556,7 @@ impl RingBuf { let buf = self.buffer_as_slice(); if contiguous { let (empty, buf) = buf.split_at(0); - (buf[self.tail..self.head], empty) + (buf.index(&(self.tail..self.head)), empty) } else { let (mid, right) = buf.split_at(self.tail); let (left, _) = mid.split_at(self.head); diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 9e5aa7d645ba0..ca1fed0f78f4c 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -55,7 +55,7 @@ //! #![feature(slicing_syntax)] //! fn main() { //! let numbers = [0i, 1i, 2i]; -//! let last_numbers = numbers[1..3]; +//! let last_numbers = numbers.index(&(1..3)); //! // last_numbers is now &[1i, 2i] //! } //! ``` @@ -98,7 +98,7 @@ use core::iter::{range, range_step, MultiplicativeIterator}; use core::kinds::Sized; use core::mem::size_of; use core::mem; -use core::ops::{FnMut, SliceMut}; +use core::ops::{FnMut, FullRange, Index, IndexMut}; use core::option::Option::{self, Some, None}; use core::ptr::PtrExt; use core::ptr; @@ -1065,12 +1065,12 @@ impl ElementSwaps { #[unstable = "trait is unstable"] impl BorrowFrom> for [T] { - fn borrow_from(owned: &Vec) -> &[T] { owned[] } + fn borrow_from(owned: &Vec) -> &[T] { owned.index(&FullRange) } } #[unstable = "trait is unstable"] impl BorrowFromMut> for [T] { - fn borrow_from_mut(owned: &mut Vec) -> &mut [T] { owned.as_mut_slice_() } + fn borrow_from_mut(owned: &mut Vec) -> &mut [T] { owned.index_mut(&FullRange) } } #[unstable = "trait is unstable"] @@ -1606,7 +1606,7 @@ mod tests { // Test on stack. let vec_stack: &[_] = &[1i, 2, 3]; - let v_b = vec_stack[1u..3u].to_vec(); + let v_b = vec_stack.index(&(1u..3u)).to_vec(); assert_eq!(v_b.len(), 2u); let v_b = v_b.as_slice(); assert_eq!(v_b[0], 2); @@ -1614,7 +1614,7 @@ mod tests { // Test `Box<[T]>` let vec_unique = vec![1i, 2, 3, 4, 5, 6]; - let v_d = vec_unique[1u..6u].to_vec(); + let v_d = vec_unique.index(&(1u..6u)).to_vec(); assert_eq!(v_d.len(), 5u); let v_d = v_d.as_slice(); assert_eq!(v_d[0], 2); @@ -1627,21 +1627,21 @@ mod tests { #[test] fn test_slice_from() { let vec: &[int] = &[1, 2, 3, 4]; - assert_eq!(vec[0..], vec); + assert_eq!(vec.index(&(0..)), vec); let b: &[int] = &[3, 4]; - assert_eq!(vec[2..], b); + assert_eq!(vec.index(&(2..)), b); let b: &[int] = &[]; - assert_eq!(vec[4..], b); + assert_eq!(vec.index(&(4..)), b); } #[test] fn test_slice_to() { let vec: &[int] = &[1, 2, 3, 4]; - assert_eq!(vec[..4], vec); + assert_eq!(vec.index(&(0..4)), vec); let b: &[int] = &[1, 2]; - assert_eq!(vec[..2], b); + assert_eq!(vec.index(&(0..2)), b); let b: &[int] = &[]; - assert_eq!(vec[..0], b); + assert_eq!(vec.index(&(0..0)), b); } @@ -2567,7 +2567,7 @@ mod tests { } assert_eq!(cnt, 3); - for f in v[1..3].iter() { + for f in v.index(&(1..3)).iter() { assert!(*f == Foo); cnt += 1; } diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index c0482702ccdb6..cb4264ec34f32 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -60,7 +60,7 @@ use core::char::CharExt; use core::clone::Clone; use core::iter::AdditiveIterator; use core::iter::{range, Iterator, IteratorExt}; -use core::ops; +use core::ops::{self, llRange, Index}; use core::option::Option::{self, Some, None}; use core::slice::AsSlice; use core::str as core_str; @@ -386,7 +386,7 @@ macro_rules! utf8_acc_cont_byte { #[unstable = "trait is unstable"] impl BorrowFrom for str { - fn borrow_from(owned: &String) -> &str { owned[] } + fn borrow_from(owned: &String) -> &str { owned.index(&FullRange) } } #[unstable = "trait is unstable"] @@ -408,7 +408,7 @@ Section: Trait implementations /// Any string that can be represented as a slice. #[stable] -pub trait StrExt: ops::Slice { +pub trait StrExt: Index { /// Escapes each char in `s` with `char::escape_default`. #[unstable = "return type may change to be an iterator"] fn escape_default(&self) -> String { @@ -464,7 +464,7 @@ pub trait StrExt: ops::Slice { #[unstable = "this functionality may be moved to libunicode"] fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { - iter: self[].chars(), + iter: self.index(&FullRange).chars(), buffer: Vec::new(), sorted: false, kind: Canonical @@ -477,7 +477,7 @@ pub trait StrExt: ops::Slice { #[unstable = "this functionality may be moved to libunicode"] fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { - iter: self[].chars(), + iter: self.index(&FullRange).chars(), buffer: Vec::new(), sorted: false, kind: Compatible @@ -525,7 +525,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn contains(&self, pat: &str) -> bool { - core_str::StrExt::contains(self[], pat) + core_str::StrExt::contains(self.index(&FullRange), pat) } /// Returns true if a string contains a char pattern. @@ -541,7 +541,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "might get removed in favour of a more generic contains()"] fn contains_char(&self, pat: P) -> bool { - core_str::StrExt::contains_char(self[], pat) + core_str::StrExt::contains_char(self.index(&FullRange), pat) } /// An iterator over the characters of `self`. Note, this iterates @@ -555,7 +555,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn chars(&self) -> Chars { - core_str::StrExt::chars(self[]) + core_str::StrExt::chars(self.index(&FullRange)) } /// An iterator over the bytes of `self` @@ -568,13 +568,13 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn bytes(&self) -> Bytes { - core_str::StrExt::bytes(self[]) + core_str::StrExt::bytes(self.index(&FullRange)) } /// An iterator over the characters of `self` and their byte offsets. #[stable] fn char_indices(&self) -> CharIndices { - core_str::StrExt::char_indices(self[]) + core_str::StrExt::char_indices(self.index(&FullRange)) } /// An iterator over substrings of `self`, separated by characters @@ -597,7 +597,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn split(&self, pat: P) -> Split

{ - core_str::StrExt::split(self[], pat) + core_str::StrExt::split(self.index(&FullRange), pat) } /// An iterator over substrings of `self`, separated by characters @@ -624,7 +624,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn splitn(&self, count: uint, pat: P) -> SplitN

{ - core_str::StrExt::splitn(self[], count, pat) + core_str::StrExt::splitn(self.index(&FullRange), count, pat) } /// An iterator over substrings of `self`, separated by characters @@ -653,7 +653,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "might get removed"] fn split_terminator(&self, pat: P) -> SplitTerminator

{ - core_str::StrExt::split_terminator(self[], pat) + core_str::StrExt::split_terminator(self.index(&FullRange), pat) } /// An iterator over substrings of `self`, separated by characters @@ -674,7 +674,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn rsplitn(&self, count: uint, pat: P) -> RSplitN

")); @@ -1542,7 +1549,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2)); - debug!("{}", indices); + debug!("{:?}", indices); let mut curty = None; for &idx in indices.iter() { let myitem = &items[idx]; @@ -1626,7 +1633,16 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, } struct Initializer<'a>(&'a str); + +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Initializer<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Initializer<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Initializer(s) = *self; if s.len() == 0 { return Ok(()); } @@ -2127,7 +2143,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { try!(assoc_type(w, item, typaram)); try!(write!(w, "

\n")); } - _ => panic!("can't make docs for trait item with name {}", item.name) + _ => panic!("can't make docs for trait item with name {:?}", item.name) } match item.doc_value() { Some(s) if dox => { @@ -2188,7 +2204,15 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item, document(w, it) } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Sidebar<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Sidebar<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let cx = self.cx; let it = self.item; @@ -2243,7 +2267,15 @@ impl<'a> fmt::Show for Sidebar<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Source<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Source<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let Source(s) = *self; let lines = s.lines().count(); diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs index 71313ea90b8ae..17d3f511d0928 100644 --- a/src/librustdoc/html/toc.rs +++ b/src/librustdoc/html/toc.rs @@ -176,7 +176,15 @@ impl TocBuilder { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for Toc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for Toc { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "

{ - core_str::StrExt::rsplitn(self[], count, pat) + core_str::StrExt::rsplitn(self.index(&FullRange), count, pat) } /// An iterator over the start and end indices of the disjoint @@ -699,7 +699,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "might have its iterator type changed"] fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> { - core_str::StrExt::match_indices(self[], pat) + core_str::StrExt::match_indices(self.index(&FullRange), pat) } /// An iterator over the substrings of `self` separated by the pattern `sep`. @@ -715,7 +715,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "might get removed in the future in favor of a more generic split()"] fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> { - core_str::StrExt::split_str(self[], pat) + core_str::StrExt::split_str(self.index(&FullRange), pat) } /// An iterator over the lines of a string (subsequences separated @@ -731,7 +731,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn lines(&self) -> Lines { - core_str::StrExt::lines(self[]) + core_str::StrExt::lines(self.index(&FullRange)) } /// An iterator over the lines of a string, separated by either @@ -747,7 +747,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn lines_any(&self) -> LinesAny { - core_str::StrExt::lines_any(self[]) + core_str::StrExt::lines_any(self.index(&FullRange)) } /// Returns a slice of the given string from the byte range @@ -782,7 +782,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "use slice notation [a..b] instead"] fn slice(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice(self[], begin, end) + core_str::StrExt::slice(self.index(&FullRange), begin, end) } /// Returns a slice of the string from `begin` to its end. @@ -795,7 +795,7 @@ pub trait StrExt: ops::Slice { /// See also `slice`, `slice_to` and `slice_chars`. #[unstable = "use slice notation [a..] instead"] fn slice_from(&self, begin: uint) -> &str { - core_str::StrExt::slice_from(self[], begin) + core_str::StrExt::slice_from(self.index(&FullRange), begin) } /// Returns a slice of the string from the beginning to byte @@ -809,7 +809,7 @@ pub trait StrExt: ops::Slice { /// See also `slice`, `slice_from` and `slice_chars`. #[unstable = "use slice notation [0..a] instead"] fn slice_to(&self, end: uint) -> &str { - core_str::StrExt::slice_to(self[], end) + core_str::StrExt::slice_to(self.index(&FullRange), end) } /// Returns a slice of the string from the character range @@ -837,7 +837,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "may have yet to prove its worth"] fn slice_chars(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice_chars(self[], begin, end) + core_str::StrExt::slice_chars(self.index(&FullRange), begin, end) } /// Takes a bytewise (not UTF-8) slice from a string. @@ -848,7 +848,7 @@ pub trait StrExt: ops::Slice { /// the entire slice as well. #[stable] unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str { - core_str::StrExt::slice_unchecked(self[], begin, end) + core_str::StrExt::slice_unchecked(self.index(&FullRange), begin, end) } /// Returns true if the pattern `pat` is a prefix of the string. @@ -860,7 +860,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn starts_with(&self, pat: &str) -> bool { - core_str::StrExt::starts_with(self[], pat) + core_str::StrExt::starts_with(self.index(&FullRange), pat) } /// Returns true if the pattern `pat` is a suffix of the string. @@ -872,7 +872,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn ends_with(&self, pat: &str) -> bool { - core_str::StrExt::ends_with(self[], pat) + core_str::StrExt::ends_with(self.index(&FullRange), pat) } /// Returns a string with all pre- and suffixes that match @@ -892,7 +892,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn trim_matches(&self, pat: P) -> &str { - core_str::StrExt::trim_matches(self[], pat) + core_str::StrExt::trim_matches(self.index(&FullRange), pat) } /// Returns a string with all prefixes that match @@ -912,7 +912,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn trim_left_matches(&self, pat: P) -> &str { - core_str::StrExt::trim_left_matches(self[], pat) + core_str::StrExt::trim_left_matches(self.index(&FullRange), pat) } /// Returns a string with all suffixes that match @@ -932,7 +932,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn trim_right_matches(&self, pat: P) -> &str { - core_str::StrExt::trim_right_matches(self[], pat) + core_str::StrExt::trim_right_matches(self.index(&FullRange), pat) } /// Check that `index`-th byte lies at the start and/or end of a @@ -960,7 +960,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "naming is uncertain with container conventions"] fn is_char_boundary(&self, index: uint) -> bool { - core_str::StrExt::is_char_boundary(self[], index) + core_str::StrExt::is_char_boundary(self.index(&FullRange), index) } /// Pluck a character out of a string and return the index of the next @@ -1018,7 +1018,7 @@ pub trait StrExt: ops::Slice { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_range_at(&self, start: uint) -> CharRange { - core_str::StrExt::char_range_at(self[], start) + core_str::StrExt::char_range_at(self.index(&FullRange), start) } /// Given a byte position and a str, return the previous char and its position. @@ -1033,7 +1033,7 @@ pub trait StrExt: ops::Slice { /// If `i` is not an index following a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_range_at_reverse(&self, start: uint) -> CharRange { - core_str::StrExt::char_range_at_reverse(self[], start) + core_str::StrExt::char_range_at_reverse(self.index(&FullRange), start) } /// Plucks the character starting at the `i`th byte of a string. @@ -1053,7 +1053,7 @@ pub trait StrExt: ops::Slice { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_at(&self, i: uint) -> char { - core_str::StrExt::char_at(self[], i) + core_str::StrExt::char_at(self.index(&FullRange), i) } /// Plucks the character ending at the `i`th byte of a string. @@ -1064,7 +1064,7 @@ pub trait StrExt: ops::Slice { /// If `i` is not an index following a valid UTF-8 character. #[unstable = "naming is uncertain with container conventions"] fn char_at_reverse(&self, i: uint) -> char { - core_str::StrExt::char_at_reverse(self[], i) + core_str::StrExt::char_at_reverse(self.index(&FullRange), i) } /// Work with the byte buffer of a string as a byte slice. @@ -1076,7 +1076,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn as_bytes(&self) -> &[u8] { - core_str::StrExt::as_bytes(self[]) + core_str::StrExt::as_bytes(self.index(&FullRange)) } /// Returns the byte index of the first character of `self` that @@ -1104,7 +1104,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn find(&self, pat: P) -> Option { - core_str::StrExt::find(self[], pat) + core_str::StrExt::find(self.index(&FullRange), pat) } /// Returns the byte index of the last character of `self` that @@ -1132,7 +1132,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn rfind(&self, pat: P) -> Option { - core_str::StrExt::rfind(self[], pat) + core_str::StrExt::rfind(self.index(&FullRange), pat) } /// Returns the byte index of the first matching substring @@ -1156,7 +1156,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "might get removed in favor of a more generic find in the future"] fn find_str(&self, needle: &str) -> Option { - core_str::StrExt::find_str(self[], needle) + core_str::StrExt::find_str(self.index(&FullRange), needle) } /// Retrieves the first character from a string slice and returns @@ -1179,7 +1179,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "awaiting conventions about shifting and slices"] fn slice_shift_char(&self) -> Option<(char, &str)> { - core_str::StrExt::slice_shift_char(self[]) + core_str::StrExt::slice_shift_char(self.index(&FullRange)) } /// Returns the byte offset of an inner slice relative to an enclosing outer slice. @@ -1198,7 +1198,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "awaiting convention about comparability of arbitrary slices"] fn subslice_offset(&self, inner: &str) -> uint { - core_str::StrExt::subslice_offset(self[], inner) + core_str::StrExt::subslice_offset(self.index(&FullRange), inner) } /// Return an unsafe pointer to the strings buffer. @@ -1209,13 +1209,13 @@ pub trait StrExt: ops::Slice { #[stable] #[inline] fn as_ptr(&self) -> *const u8 { - core_str::StrExt::as_ptr(self[]) + core_str::StrExt::as_ptr(self.index(&FullRange)) } /// Return an iterator of `u16` over the string encoded as UTF-16. #[unstable = "this functionality may only be provided by libunicode"] fn utf16_units(&self) -> Utf16Units { - Utf16Units { encoder: Utf16Encoder::new(self[].chars()) } + Utf16Units { encoder: Utf16Encoder::new(self.index(&FullRange).chars()) } } /// Return the number of bytes in this string @@ -1229,7 +1229,7 @@ pub trait StrExt: ops::Slice { #[stable] #[inline] fn len(&self) -> uint { - core_str::StrExt::len(self[]) + core_str::StrExt::len(self.index(&FullRange)) } /// Returns true if this slice contains no bytes @@ -1242,7 +1242,7 @@ pub trait StrExt: ops::Slice { #[inline] #[stable] fn is_empty(&self) -> bool { - core_str::StrExt::is_empty(self[]) + core_str::StrExt::is_empty(self.index(&FullRange)) } /// Parse this string into the specified type. @@ -1256,7 +1256,7 @@ pub trait StrExt: ops::Slice { #[inline] #[unstable = "this method was just created"] fn parse(&self) -> Option { - core_str::StrExt::parse(self[]) + core_str::StrExt::parse(self.index(&FullRange)) } /// Returns an iterator over the @@ -1280,7 +1280,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "this functionality may only be provided by libunicode"] fn graphemes(&self, is_extended: bool) -> Graphemes { - UnicodeStr::graphemes(self[], is_extended) + UnicodeStr::graphemes(self.index(&FullRange), is_extended) } /// Returns an iterator over the grapheme clusters of self and their byte offsets. @@ -1295,7 +1295,7 @@ pub trait StrExt: ops::Slice { /// ``` #[unstable = "this functionality may only be provided by libunicode"] fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { - UnicodeStr::grapheme_indices(self[], is_extended) + UnicodeStr::grapheme_indices(self.index(&FullRange), is_extended) } /// An iterator over the words of a string (subsequences separated @@ -1311,7 +1311,7 @@ pub trait StrExt: ops::Slice { /// ``` #[stable] fn words(&self) -> Words { - UnicodeStr::words(self[]) + UnicodeStr::words(self.index(&FullRange)) } /// Returns a string's displayed width in columns, treating control @@ -1325,25 +1325,25 @@ pub trait StrExt: ops::Slice { /// `is_cjk` = `false`) if the locale is unknown. #[unstable = "this functionality may only be provided by libunicode"] fn width(&self, is_cjk: bool) -> uint { - UnicodeStr::width(self[], is_cjk) + UnicodeStr::width(self.index(&FullRange), is_cjk) } /// Returns a string with leading and trailing whitespace removed. #[stable] fn trim(&self) -> &str { - UnicodeStr::trim(self[]) + UnicodeStr::trim(self.index(&FullRange)) } /// Returns a string with leading whitespace removed. #[stable] fn trim_left(&self) -> &str { - UnicodeStr::trim_left(self[]) + UnicodeStr::trim_left(self.index(&FullRange)) } /// Returns a string with trailing whitespace removed. #[stable] fn trim_right(&self) -> &str { - UnicodeStr::trim_right(self[]) + UnicodeStr::trim_right(self.index(&FullRange)) } } @@ -2133,7 +2133,7 @@ mod tests { let mut bytes = [0u8; 4]; for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) { let len = c.encode_utf8(&mut bytes).unwrap_or(0); - let s = ::core::str::from_utf8(bytes[..len]).unwrap(); + let s = ::core::str::from_utf8(bytes.index(&(0..len))).unwrap(); if Some(c) != s.chars().next() { panic!("character {:x}={} does not decode correctly", c as u32, c); } @@ -2145,7 +2145,7 @@ mod tests { let mut bytes = [0u8; 4]; for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) { let len = c.encode_utf8(&mut bytes).unwrap_or(0); - let s = ::core::str::from_utf8(bytes[..len]).unwrap(); + let s = ::core::str::from_utf8(bytes.index(&(0..len))).unwrap(); if Some(c) != s.chars().rev().next() { panic!("character {:x}={} does not decode correctly", c as u32, c); } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index b05b5e276e867..69ff513a85bb3 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -168,7 +168,7 @@ impl String { if i > 0 { unsafe { - res.as_mut_vec().push_all(v[..i]) + res.as_mut_vec().push_all(v.index(&(0..i))) }; } @@ -185,7 +185,7 @@ impl String { macro_rules! error { () => ({ unsafe { if subseqidx != i_ { - res.as_mut_vec().push_all(v[subseqidx..i_]); + res.as_mut_vec().push_all(v.index(&(subseqidx..i_))); } subseqidx = i; res.as_mut_vec().push_all(REPLACEMENT); @@ -254,7 +254,7 @@ impl String { } if subseqidx < total { unsafe { - res.as_mut_vec().push_all(v[subseqidx..total]) + res.as_mut_vec().push_all(v.index(&(subseqidx..total))) }; } Cow::Owned(res) @@ -818,30 +818,30 @@ impl<'a> Add<&'a str> for String { } } -impl ops::Index, str> for String { +impl ops::Index, str> for String { #[inline] - fn index(&self, &index: &ops::Range) -> &str { - self[][*index] + fn index(&self, index: &ops::Range) -> &str { + &self.index(&FullRange)[*index] } } -impl ops::Index, str> for String { +impl ops::Index, str> for String { #[inline] - fn index(&self, &index: &ops::RangeTo) -> &str { - self[][*index] + fn index(&self, index: &ops::RangeTo) -> &str { + &self.index(&FullRange)[*index] } } -impl ops::Index, str> for String { +impl ops::Index, str> for String { #[inline] - fn index(&self, &index: &ops::RangeFrom) -> &str { - self[][*index] + fn index(&self, index: &ops::RangeFrom) -> &str { + &self.index(&FullRange)[*index] } } -impl ops::Index, str> for String { +impl ops::Index for String { #[inline] - fn index(&self, &index: &ops::FullRange) -> &str { + fn index(&self, _index: &ops::FullRange) -> &str { unsafe { mem::transmute(self.vec.as_slice()) } } } @@ -851,7 +851,7 @@ impl ops::Deref for String { type Target = str; fn deref<'a>(&'a self) -> &'a str { - unsafe { mem::transmute(self.vec[]) } + unsafe { mem::transmute(self.vec.index(&FullRange)) } } } @@ -1230,10 +1230,10 @@ mod tests { #[test] fn test_slicing() { let s = "foobar".to_string(); - assert_eq!("foobar", s[]); - assert_eq!("foo", s[..3]); - assert_eq!("bar", s[3..]); - assert_eq!("oob", s[1..4]); + assert_eq!("foobar", s.index(&FullRange)); + assert_eq!("foo", s.index(&(0..3))); + assert_eq!("bar", s.index(&(3..))); + assert_eq!("oob", s.index(&(1..4))); } #[test] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index c057939df2b42..3f667698bae53 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1178,7 +1178,7 @@ impl Clone for Vec { // self.len <= other.len due to the truncate above, so the // slice here is always in-bounds. - let slice = other[self.len()..]; + let slice = other.index(&(self.len()..)); self.push_all(slice); } } @@ -1209,65 +1209,58 @@ impl IndexMut for Vec { } } -impl ops::Slice for Vec { - #[inline] - fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T { - &mut self.as_mut_slice()[*index] - } -} - impl ops::Index, [T]> for Vec { #[inline] - fn index(&self, &index: &ops::Range) -> &[T] { + fn index(&self, index: &ops::Range) -> &[T] { self.as_slice().index(index) } } impl ops::Index, [T]> for Vec { #[inline] - fn index(&self, &index: &ops::RangeTo) -> &[T] { + fn index(&self, index: &ops::RangeTo) -> &[T] { self.as_slice().index(index) } } impl ops::Index, [T]> for Vec { #[inline] - fn index(&self, &index: &ops::RangeFrom) -> &[T] { + fn index(&self, index: &ops::RangeFrom) -> &[T] { self.as_slice().index(index) } } -impl ops::Index, [T]> for Vec { +impl ops::Index for Vec { #[inline] - fn index(&self, &index: &ops::FullRange) -> &[T] { + fn index(&self, _index: &ops::FullRange) -> &[T] { self.as_slice() } } impl ops::IndexMut, [T]> for Vec { #[inline] - fn index_mut(&mut self, &index: &ops::Range) -> &mut [T] { + fn index_mut(&mut self, index: &ops::Range) -> &mut [T] { self.as_mut_slice().index_mut(index) } } impl ops::IndexMut, [T]> for Vec { #[inline] - fn index_mut(&mut self, &index: &ops::RangeTo) -> &mut [T] { + fn index_mut(&mut self, index: &ops::RangeTo) -> &mut [T] { self.as_mut_slice().index_mut(index) } } impl ops::IndexMut, [T]> for Vec { #[inline] - fn index_mut(&mut self, &index: &ops::RangeFrom) -> &mut [T] { + fn index_mut(&mut self, index: &ops::RangeFrom) -> &mut [T] { self.as_mut_slice().index_mut(index) } } -impl ops::IndexMut, [T]> for Vec { +impl ops::IndexMut for Vec { #[inline] - fn index_mut(&mut self, &index: &ops::FullRange) -> &mut [T] { + fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] { self.as_mut_slice() } } @@ -2125,7 +2118,7 @@ mod tests { #[should_fail] fn test_slice_out_of_bounds_2() { let x: Vec = vec![1, 2, 3, 4, 5]; - x[..6]; + x.index(&(0..6)); } #[test] @@ -2139,14 +2132,14 @@ mod tests { #[should_fail] fn test_slice_out_of_bounds_4() { let x: Vec = vec![1, 2, 3, 4, 5]; - x[1..6]; + x.index(&(1..6)); } #[test] #[should_fail] fn test_slice_out_of_bounds_5() { let x: Vec = vec![1, 2, 3, 4, 5]; - x[3..2]; + x.index(&(3..2)); } #[test] diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index cc757b656238e..68469059fead0 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -455,7 +455,8 @@ impl VecMap { if *key >= self.v.len() { return None; } - self.v[*key].take() + let result = &mut self.v[*key]; + result.take() } } diff --git a/src/libcore/array.rs b/src/libcore/array.rs index ba7714ad9bc8c..37a2177b38d0c 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -18,7 +18,7 @@ use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use fmt; use kinds::Copy; -use ops::Deref; +use ops::{Deref, FullRange, Index}; use option::Option; // macro for implementing n-ary tuple functions and operations @@ -35,7 +35,7 @@ macro_rules! array_impls { #[unstable = "waiting for Show to stabilize"] impl fmt::Show for [T; $N] { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Show::fmt(&self[], f) + fmt::Show::fmt(&self.index(&FullRange), f) } } @@ -43,11 +43,11 @@ macro_rules! array_impls { impl PartialEq<[B; $N]> for [A; $N] where A: PartialEq { #[inline] fn eq(&self, other: &[B; $N]) -> bool { - self[] == other[] + self.index(&FullRange) == other.index(&FullRange) } #[inline] fn ne(&self, other: &[B; $N]) -> bool { - self[] != other[] + self.index(&FullRange) != other.index(&FullRange) } } @@ -57,9 +57,9 @@ macro_rules! array_impls { Rhs: Deref, { #[inline(always)] - fn eq(&self, other: &Rhs) -> bool { PartialEq::eq(self[], &**other) } + fn eq(&self, other: &Rhs) -> bool { PartialEq::eq(self.index(&FullRange), &**other) } #[inline(always)] - fn ne(&self, other: &Rhs) -> bool { PartialEq::ne(self[], &**other) } + fn ne(&self, other: &Rhs) -> bool { PartialEq::ne(self.index(&FullRange), &**other) } } #[stable] @@ -68,9 +68,9 @@ macro_rules! array_impls { Lhs: Deref { #[inline(always)] - fn eq(&self, other: &[B; $N]) -> bool { PartialEq::eq(&**self, other[]) } + 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[]) } + fn ne(&self, other: &[B; $N]) -> bool { PartialEq::ne(&**self, other.index(&FullRange)) } } #[stable] @@ -80,23 +80,23 @@ macro_rules! array_impls { impl PartialOrd for [T; $N] { #[inline] fn partial_cmp(&self, other: &[T; $N]) -> Option { - PartialOrd::partial_cmp(&self[], &other[]) + PartialOrd::partial_cmp(&self.index(&FullRange), &other.index(&FullRange)) } #[inline] fn lt(&self, other: &[T; $N]) -> bool { - PartialOrd::lt(&self[], &other[]) + PartialOrd::lt(&self.index(&FullRange), &other.index(&FullRange)) } #[inline] fn le(&self, other: &[T; $N]) -> bool { - PartialOrd::le(&self[], &other[]) + PartialOrd::le(&self.index(&FullRange), &other.index(&FullRange)) } #[inline] fn ge(&self, other: &[T; $N]) -> bool { - PartialOrd::ge(&self[], &other[]) + PartialOrd::ge(&self.index(&FullRange), &other.index(&FullRange)) } #[inline] fn gt(&self, other: &[T; $N]) -> bool { - PartialOrd::gt(&self[], &other[]) + PartialOrd::gt(&self.index(&FullRange), &other.index(&FullRange)) } } @@ -104,7 +104,7 @@ macro_rules! array_impls { impl Ord for [T; $N] { #[inline] fn cmp(&self, other: &[T; $N]) -> Ordering { - Ord::cmp(&self[], &other[]) + Ord::cmp(&self.index(&FullRange), &other.index(&FullRange)) } } )+ diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index f63242b4f859a..d833b8fed7779 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -20,7 +20,7 @@ use fmt; use iter::{IteratorExt, range}; use num::{cast, Float, ToPrimitive}; use num::FpCategory as Fp; -use ops::FnOnce; +use ops::{FnOnce, Index}; use result::Result::Ok; use slice::{self, SliceExt}; use str::{self, StrExt}; @@ -332,5 +332,5 @@ pub fn float_to_str_bytes_common( } } - f(unsafe { str::from_utf8_unchecked(buf[..end]) }) + f(unsafe { str::from_utf8_unchecked(buf.index(&(0..end))) }) } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 951f5c29f00e8..19c6b29417ffd 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -19,8 +19,8 @@ use kinds::{Copy, Sized}; use mem; use option::Option; use option::Option::{Some, None}; -use ops::{Deref, FnOnce}; use result::Result::Ok; +use ops::{Deref, FnOnce, Index}; use result; use slice::SliceExt; use slice; @@ -413,7 +413,7 @@ impl<'a> Formatter<'a> { for c in sign.into_iter() { let mut b = [0; 4]; let n = c.encode_utf8(&mut b).unwrap_or(0); - let b = unsafe { str::from_utf8_unchecked(b[0..n]) }; + let b = unsafe { str::from_utf8_unchecked(b.index(&(0..n))) }; try!(f.buf.write_str(b)); } if prefixed { f.buf.write_str(prefix) } @@ -620,7 +620,7 @@ impl Show for char { let mut utf8 = [0u8; 4]; let amt = self.encode_utf8(&mut utf8).unwrap_or(0); - let s: &str = unsafe { mem::transmute(utf8[..amt]) }; + let s: &str = unsafe { mem::transmute(utf8.index(&(0..amt))) }; Show::fmt(s, f) } } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index e0724fc2da5f5..89337e0584b50 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -16,6 +16,7 @@ use fmt; use iter::IteratorExt; +use ops::Index; use num::{Int, cast}; use slice::SliceExt; use str; @@ -61,7 +62,7 @@ trait GenericRadix { if x == zero { break }; // No more digits left to accumulate. } } - let buf = unsafe { str::from_utf8_unchecked(buf[curr..]) }; + let buf = unsafe { str::from_utf8_unchecked(buf.index(&(curr..))) }; f.pad_integral(is_positive, self.prefix(), buf) } } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 192d6063f6bbc..3bcdd54463fc6 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -24,7 +24,7 @@ use iter::IteratorExt; use kinds::Copy; use mem::size_of; use ops::{Add, Sub, Mul, Div, Rem, Neg}; -use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; +use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index}; use option::Option; use option::Option::{Some, None}; use str::{FromStr, StrExt}; @@ -1577,7 +1577,7 @@ macro_rules! from_str_radix_float_impl { }; // Parse the exponent as decimal integer - let src = src[offset..]; + let src = src.index(&(offset..)); let (is_positive, exp) = match src.slice_shift_char() { Some(('-', src)) => (false, src.parse::()), Some(('+', src)) => (true, src.parse::()), diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 369652b215f24..a0bb0205c4287 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -43,7 +43,7 @@ use default::Default; use iter::*; use kinds::Copy; use num::Int; -use ops::{FnMut, self}; +use ops::{FnMut, self, Index}; use option::Option; use option::Option::{None, Some}; use result::Result; @@ -159,7 +159,7 @@ impl SliceExt for [T] { #[inline] fn split_at(&self, mid: uint) -> (&[T], &[T]) { - (self[..mid], self[mid..]) + (self.index(&(0..mid)), self.index(&(mid..))) } #[inline] @@ -236,11 +236,11 @@ impl SliceExt for [T] { } #[inline] - fn tail(&self) -> &[T] { self[1..] } + fn tail(&self) -> &[T] { self.index(&(1..)) } #[inline] fn init(&self) -> &[T] { - self[..self.len() - 1] + self.index(&(0..(self.len() - 1))) } #[inline] @@ -443,13 +443,13 @@ impl SliceExt for [T] { #[inline] fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq { let n = needle.len(); - self.len() >= n && needle == self[..n] + self.len() >= n && needle == self.index(&(0..n)) } #[inline] fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq { let (m, n) = (self.len(), needle.len()); - m >= n && needle == self[m-n..] + m >= n && needle == self.index(&((m-n)..)) } #[unstable] @@ -622,6 +622,20 @@ impl ops::IndexMut for [T] { } } +impl ops::Index, [T]> for [T] { + #[inline] + fn index(&self, index: &ops::Range) -> &[T] { + assert!(index.start <= index.end); + assert!(index.end <= self.len()); + unsafe { + transmute(RawSlice { + data: self.as_ptr().offset(index.start as int), + len: index.end - index.start + }) + } + } +} + //////////////////////////////////////////////////////////////////////////////// // Common traits @@ -779,7 +793,7 @@ impl<'a, T> ops::Index, [T]> for Iter<'a, T> { #[experimental] impl<'a, T> ops::Index for Iter<'a, T> { #[inline] - fn index(&self, index: &ops::FullRange) -> &[T] { + fn index(&self, _index: &ops::FullRange) -> &[T] { self.as_slice() } } @@ -868,7 +882,7 @@ impl<'a, T> ops::Index, [T]> for IterMut<'a, T> { #[experimental] impl<'a, T> ops::Index for IterMut<'a, T> { #[inline] - fn index(&self, index: &ops::FullRange) -> &[T] { + fn index(&self, _index: &ops::FullRange) -> &[T] { make_slice!(T -> &[T]: self.ptr, self.end) } } @@ -900,7 +914,7 @@ impl<'a, T> ops::IndexMut, [T]> for IterMut<'a, T> { #[experimental] impl<'a, T> ops::IndexMut for IterMut<'a, T> { #[inline] - fn index_mut(&mut self, index: &ops::FullRange) -> &mut [T] { + fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] { make_slice!(T -> &mut [T]: self.ptr, self.end) } } @@ -964,8 +978,8 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool { match self.v.iter().position(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v[..idx]); - self.v = self.v[idx + 1..]; + let ret = Some(self.v.index(&(0..idx))); + self.v = self.v.index(&((idx + 1)..)); ret } } @@ -990,8 +1004,8 @@ impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> boo match self.v.iter().rposition(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v[idx + 1..]); - self.v = self.v[..idx]; + let ret = Some(self.v.index(&((idx + 1)..))); + self.v = self.v.index(&(0..idx)); ret } } @@ -1187,8 +1201,8 @@ impl<'a, T> Iterator for Windows<'a, T> { if self.size > self.v.len() { None } else { - let ret = Some(self.v[..self.size]); - self.v = self.v[1..]; + let ret = Some(self.v.index(&(0..self.size))); + self.v = self.v.index(&(1..)); ret } } @@ -1275,7 +1289,7 @@ impl<'a, T> RandomAccessIterator for Chunks<'a, T> { let mut hi = lo + self.size; if hi < lo || hi > self.v.len() { hi = self.v.len(); } - Some(self.v[lo..hi]) + Some(self.v.index(&(lo..hi))) } else { None } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a28e56144177e..c4e97fe3b7fb3 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -26,7 +26,7 @@ use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator}; use kinds::Sized; use mem; use num::Int; -use ops::{Fn, FnMut}; +use ops::{Fn, FnMut, Index}; use option::Option::{self, None, Some}; use ptr::PtrExt; use raw::{Repr, Slice}; @@ -581,7 +581,7 @@ impl NaiveSearcher { fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> { while self.position + needle.len() <= haystack.len() { - if haystack[self.position .. self.position + needle.len()] == needle { + if haystack.index(&(self.position .. self.position + needle.len())) == needle { let match_pos = self.position; self.position += needle.len(); // add 1 for all matches return Some((match_pos, match_pos + needle.len())); @@ -702,10 +702,10 @@ impl TwoWaySearcher { // // What's going on is we have some critical factorization (u, v) of the // needle, and we want to determine whether u is a suffix of - // v[..period]. If it is, we use "Algorithm CP1". Otherwise we use + // v.index(&(0..period)). If it is, we use "Algorithm CP1". Otherwise we use // "Algorithm CP2", which is optimized for when the period of the needle // is large. - if needle[..crit_pos] == needle[period.. period + crit_pos] { + if needle.index(&(0..crit_pos)) == needle.index(&(period.. period + crit_pos)) { TwoWaySearcher { crit_pos: crit_pos, period: period, @@ -1121,28 +1121,28 @@ mod traits { impl ops::Index, str> for str { #[inline] - fn index(&self, &index: &ops::Range) -> &str { + fn index(&self, index: &ops::Range) -> &str { self.slice(index.start, index.end) } } impl ops::Index, str> for str { #[inline] - fn index(&self, &index: &ops::RangeTo) -> &str { + fn index(&self, index: &ops::RangeTo) -> &str { self.slice_to(index.end) } } impl ops::Index, str> for str { #[inline] - fn index(&self, &index: &ops::RangeFrom) -> &str { + fn index(&self, index: &ops::RangeFrom) -> &str { self.slice_from(index.start) } } impl ops::Index for str { #[inline] - fn index(&self, &index: &ops::FullRange) -> &str { + fn index(&self, _index: &ops::FullRange) -> &str { self } } @@ -1412,13 +1412,13 @@ impl StrExt for str { #[inline] fn starts_with(&self, needle: &str) -> bool { let n = needle.len(); - self.len() >= n && needle.as_bytes() == self.as_bytes()[..n] + self.len() >= n && needle.as_bytes() == self.as_bytes().index(&(0..n)) } #[inline] fn ends_with(&self, needle: &str) -> bool { let (m, n) = (self.len(), needle.len()); - m >= n && needle.as_bytes() == self.as_bytes()[m-n..] + m >= n && needle.as_bytes() == self.as_bytes().index(&((m-n)..)) } #[inline] diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs index b581cdbd71093..f901e8001767d 100644 --- a/src/libcoretest/char.rs +++ b/src/libcoretest/char.rs @@ -167,7 +167,7 @@ fn test_encode_utf8() { fn check(input: char, expect: &[u8]) { let mut buf = [0u8; 4]; let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0); - assert_eq!(buf[..n], expect); + assert_eq!(buf.index(&(0..n)), expect); } check('x', &[0x78]); @@ -181,7 +181,7 @@ fn test_encode_utf16() { fn check(input: char, expect: &[u16]) { let mut buf = [0u16; 2]; let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0); - assert_eq!(buf[..n], expect); + assert_eq!(buf.index(&(0..n)), expect); } check('x', &[0x0078]); diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 73db72d0313e6..19bfbf3df4417 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -230,7 +230,7 @@ fn test_inspect() { .collect::>(); assert_eq!(n, xs.len()); - assert_eq!(xs[], ys[]); + assert_eq!(xs.index(&FullRange), ys.index(&FullRange)); } #[test] @@ -281,47 +281,47 @@ fn test_iterator_nth() { fn test_iterator_last() { let v: &[_] = &[0i, 1, 2, 3, 4]; assert_eq!(v.iter().last().unwrap(), &4); - assert_eq!(v[0..1].iter().last().unwrap(), &0); + assert_eq!(v.index(&(0..1)).iter().last().unwrap(), &0); } #[test] fn test_iterator_len() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().count(), 4); - assert_eq!(v[0..10].iter().count(), 10); - assert_eq!(v[0..0].iter().count(), 0); + assert_eq!(v.index(&(0..4)).iter().count(), 4); + assert_eq!(v.index(&(0..10)).iter().count(), 10); + assert_eq!(v.index(&(0..0)).iter().count(), 0); } #[test] fn test_iterator_sum() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6); + assert_eq!(v.index(&(0..4)).iter().map(|&x| x).sum(), 6); assert_eq!(v.iter().map(|&x| x).sum(), 55); - assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0); + assert_eq!(v.index(&(0..0)).iter().map(|&x| x).sum(), 0); } #[test] fn test_iterator_product() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).product(), 0); - assert_eq!(v[1..5].iter().map(|&x| x).product(), 24); - assert_eq!(v[0..0].iter().map(|&x| x).product(), 1); + assert_eq!(v.index(&(0..4)).iter().map(|&x| x).product(), 0); + assert_eq!(v.index(&(1..5)).iter().map(|&x| x).product(), 24); + assert_eq!(v.index(&(0..0)).iter().map(|&x| x).product(), 1); } #[test] fn test_iterator_max() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).max(), Some(3)); + assert_eq!(v.index(&(0..4)).iter().map(|&x| x).max(), Some(3)); assert_eq!(v.iter().map(|&x| x).max(), Some(10)); - assert_eq!(v[0..0].iter().map(|&x| x).max(), None); + assert_eq!(v.index(&(0..0)).iter().map(|&x| x).max(), None); } #[test] fn test_iterator_min() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).min(), Some(0)); + assert_eq!(v.index(&(0..4)).iter().map(|&x| x).min(), Some(0)); assert_eq!(v.iter().map(|&x| x).min(), Some(0)); - assert_eq!(v[0..0].iter().map(|&x| x).min(), None); + assert_eq!(v.index(&(0..0)).iter().map(|&x| x).min(), None); } #[test] diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs index 9ef7d6030593a..d20def89abbdf 100644 --- a/src/libcoretest/slice.rs +++ b/src/libcoretest/slice.rs @@ -43,31 +43,31 @@ fn iterator_to_slice() { { let mut iter = data.iter(); - assert_eq!(iter[], other_data[]); + assert_eq!(iter.index(&FullRange), other_data.index(&FullRange)); iter.next(); - assert_eq!(iter[], other_data[1..]); + assert_eq!(iter.index(&FullRange), other_data.index(&(1..))); iter.next_back(); - assert_eq!(iter[], other_data[1..2]); + assert_eq!(iter.index(&FullRange), other_data.index(&(1..2))); let s = iter.as_slice(); iter.next(); - assert_eq!(s, other_data[1..2]); + assert_eq!(s, other_data.index(&(1..2))); } { let mut iter = data.iter_mut(); - assert_eq!(iter[], other_data[]); + assert_eq!(iter.index(&FullRange), other_data.index(&FullRange)); // mutability: assert!(iter[mut] == other_data); iter.next(); - assert_eq!(iter[], other_data[1..]); + assert_eq!(iter.index(&FullRange), other_data.index(&(1..))); assert!(iter[mut] == other_data[mut 1..]); iter.next_back(); - assert_eq!(iter[], other_data[1..2]); + assert_eq!(iter.index(&FullRange), other_data.index(&(1..2))); assert!(iter[mut] == other_data[mut 1..2]); let s = iter.into_slice(); diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 917c6e99992f2..3829d98c7a122 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -212,11 +212,11 @@ impl<'a> Parser<'a> { self.cur.next(); } Some((_, other)) => { - self.err(format!("expected `{}`, found `{}`", c, other)[]); + self.err(format!("expected `{}`, found `{}`", c, other).index(&FullRange)); } None => { self.err(format!("expected `{}` but string was terminated", - c)[]); + c).index(&FullRange)); } } } @@ -239,12 +239,12 @@ impl<'a> Parser<'a> { // we may not consume the character, so clone the iterator match self.cur.clone().next() { Some((pos, '}')) | Some((pos, '{')) => { - return self.input[start..pos]; + return self.input.index(&(start..pos)); } Some(..) => { self.cur.next(); } None => { self.cur.next(); - return self.input[start..self.input.len()]; + return self.input.index(&(start..self.input.len())); } } } @@ -284,7 +284,7 @@ impl<'a> Parser<'a> { flags: 0, precision: CountImplied, width: CountImplied, - ty: self.input[0..0], + ty: self.input.index(&(0..0)), }; if !self.consume(':') { return spec } @@ -393,7 +393,7 @@ impl<'a> Parser<'a> { self.cur.next(); pos } - Some(..) | None => { return self.input[0..0]; } + Some(..) | None => { return self.input.index(&(0..0)); } }; let mut end; loop { @@ -405,7 +405,7 @@ impl<'a> Parser<'a> { None => { end = self.input.len(); break } } } - self.input[start..end] + self.input.index(&(start..end)) } /// Optionally parses an integer at the current position. This doesn't deal diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 18077795e245f..a9e4e8d251452 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -281,7 +281,7 @@ impl OptGroup { impl Matches { fn opt_vals(&self, nm: &str) -> Vec { - match find_opt(self.opts[], Name::from_str(nm)) { + match find_opt(self.opts.index(&FullRange), Name::from_str(nm)) { Some(id) => self.vals[id].clone(), None => panic!("No option '{}' defined", nm) } @@ -309,7 +309,7 @@ impl Matches { /// Returns true if any of several options were matched. pub fn opts_present(&self, names: &[String]) -> bool { for nm in names.iter() { - match find_opt(self.opts.as_slice(), Name::from_str(nm[])) { + match find_opt(self.opts.as_slice(), Name::from_str(nm.index(&FullRange))) { Some(id) if !self.vals[id].is_empty() => return true, _ => (), }; @@ -320,7 +320,7 @@ impl Matches { /// Returns the string argument supplied to one of several matching options or `None`. pub fn opts_str(&self, names: &[String]) -> Option { for nm in names.iter() { - match self.opt_val(nm[]) { + match self.opt_val(nm.index(&FullRange)) { Some(Val(ref s)) => return Some(s.clone()), _ => () } @@ -585,7 +585,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { while i < l { let cur = args[i].clone(); let curlen = cur.len(); - if !is_arg(cur[]) { + if !is_arg(cur.index(&FullRange)) { free.push(cur); } else if cur == "--" { let mut j = i + 1; @@ -595,7 +595,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { let mut names; let mut i_arg = None; if cur.as_bytes()[1] == b'-' { - let tail = cur[2..curlen]; + let tail = cur.index(&(2..curlen)); let tail_eq: Vec<&str> = tail.split('=').collect(); if tail_eq.len() <= 1 { names = vec!(Long(tail.to_string())); @@ -631,7 +631,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { }; if arg_follows && range.next < curlen { - i_arg = Some(cur[range.next..curlen].to_string()); + i_arg = Some(cur.index(&(range.next..curlen)).to_string()); break; } @@ -650,29 +650,34 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { if name_pos == names.len() && !i_arg.is_none() { return Err(UnexpectedArgument(nm.to_string())); } - vals[optid].push(Given); + let v = &mut vals[optid]; + v.push(Given); } Maybe => { if !i_arg.is_none() { - vals[optid] - .push(Val((i_arg.clone()) + let v = &mut vals[optid]; + v.push(Val((i_arg.clone()) .unwrap())); } else if name_pos < names.len() || i + 1 == l || - is_arg(args[i + 1][]) { - vals[optid].push(Given); + is_arg(args[i + 1].index(&FullRange)) { + let v = &mut vals[optid]; + v.push(Given); } else { i += 1; - vals[optid].push(Val(args[i].clone())); + let v = &mut vals[optid]; + v.push(Val(args[i].clone())); } } Yes => { if !i_arg.is_none() { - vals[optid].push(Val(i_arg.clone().unwrap())); + let v = &mut vals[optid]; + v.push(Val(i_arg.clone().unwrap())); } else if i + 1 == l { return Err(ArgumentMissing(nm.to_string())); } else { i += 1; - vals[optid].push(Val(args[i].clone())); + let v = &mut vals[optid]; + v.push(Val(args[i].clone())); } } } @@ -717,7 +722,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { 0 => {} 1 => { row.push('-'); - row.push_str(short_name[]); + row.push_str(short_name.index(&FullRange)); row.push(' '); } _ => panic!("the short name should only be 1 ascii char long"), @@ -728,7 +733,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { 0 => {} _ => { row.push_str("--"); - row.push_str(long_name[]); + row.push_str(long_name.index(&FullRange)); row.push(' '); } } @@ -736,10 +741,10 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { // arg match hasarg { No => {} - Yes => row.push_str(hint[]), + Yes => row.push_str(hint.index(&FullRange)), Maybe => { row.push('['); - row.push_str(hint[]); + row.push_str(hint.index(&FullRange)); row.push(']'); } } @@ -752,7 +757,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { row.push(' '); } } else { - row.push_str(desc_sep[]); + row.push_str(desc_sep.index(&FullRange)); } // Normalize desc to contain words separated by one space character @@ -764,14 +769,14 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { // FIXME: #5516 should be graphemes not codepoints let mut desc_rows = Vec::new(); - each_split_within(desc_normalized_whitespace[], 54, |substr| { + each_split_within(desc_normalized_whitespace.index(&FullRange), 54, |substr| { desc_rows.push(substr.to_string()); true }); // FIXME: #5516 should be graphemes not codepoints // wrapped description - row.push_str(desc_rows.connect(desc_sep[])[]); + row.push_str(desc_rows.connect(desc_sep.index(&FullRange)).index(&FullRange)); row }); @@ -790,10 +795,10 @@ fn format_option(opt: &OptGroup) -> String { // Use short_name is possible, but fallback to long_name. if opt.short_name.len() > 0 { line.push('-'); - line.push_str(opt.short_name[]); + line.push_str(opt.short_name.index(&FullRange)); } else { line.push_str("--"); - line.push_str(opt.long_name[]); + line.push_str(opt.long_name.index(&FullRange)); } if opt.hasarg != No { @@ -801,7 +806,7 @@ fn format_option(opt: &OptGroup) -> String { if opt.hasarg == Maybe { line.push('['); } - line.push_str(opt.hint[]); + line.push_str(opt.hint.index(&FullRange)); if opt.hasarg == Maybe { line.push(']'); } @@ -823,7 +828,7 @@ pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> String { line.push_str(opts.iter() .map(format_option) .collect::>() - .connect(" ")[]); + .connect(" ").index(&FullRange)); line } @@ -886,9 +891,9 @@ fn each_split_within(ss: &str, lim: uint, mut it: F) -> bool where (B, Cr, UnderLim) => { B } (B, Cr, OverLim) if (i - last_start + 1) > lim => panic!("word starting with {} longer than limit!", - ss[last_start..i + 1]), + ss.index(&(last_start..(i + 1)))), (B, Cr, OverLim) => { - *cont = it(ss[slice_start..last_end]); + *cont = it(ss.index(&(slice_start..last_end))); slice_start = last_start; B } @@ -898,7 +903,7 @@ fn each_split_within(ss: &str, lim: uint, mut it: F) -> bool where } (B, Ws, OverLim) => { last_end = i; - *cont = it(ss[slice_start..last_end]); + *cont = it(ss.index(&(slice_start..last_end))); A } @@ -907,14 +912,14 @@ fn each_split_within(ss: &str, lim: uint, mut it: F) -> bool where B } (C, Cr, OverLim) => { - *cont = it(ss[slice_start..last_end]); + *cont = it(ss.index(&(slice_start..last_end))); slice_start = i; last_start = i; last_end = i; B } (C, Ws, OverLim) => { - *cont = it(ss[slice_start..last_end]); + *cont = it(ss.index(&(slice_start..last_end))); A } (C, Ws, UnderLim) => { @@ -1408,7 +1413,7 @@ mod tests { assert!(matches_single.opts_present(&["e".to_string(), "encrypt".to_string()])); assert!(!matches_single.opts_present(&["encrypt".to_string()])); assert!(!matches_single.opts_present(&["thing".to_string()])); - assert!(!matches_single.opts_present(&[])); + assert!(!matches_single.opts_present(&.index(&FullRange))); assert_eq!(matches_single.opts_str(&["e".to_string()]).unwrap(), "foo"); assert_eq!(matches_single.opts_str(&["e".to_string(), "encrypt".to_string()]).unwrap(), @@ -1429,7 +1434,7 @@ mod tests { assert!(matches_both.opts_present(&["e".to_string(), "encrypt".to_string()])); assert!(!matches_both.opts_present(&["f".to_string()])); assert!(!matches_both.opts_present(&["thing".to_string()])); - assert!(!matches_both.opts_present(&[])); + assert!(!matches_both.opts_present(&.index(&FullRange))); assert_eq!(matches_both.opts_str(&["e".to_string()]).unwrap(), "foo"); assert_eq!(matches_both.opts_str(&["encrypt".to_string()]).unwrap(), "foo"); diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 64cc490f4b163..7e8382b26c4a0 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -453,7 +453,7 @@ impl<'a> LabelText<'a> { pub fn escape(&self) -> String { match self { &LabelStr(ref s) => s.escape_default(), - &EscStr(ref s) => LabelText::escape_str(s[]), + &EscStr(ref s) => LabelText::escape_str(s.index(&FullRange)), } } @@ -482,7 +482,7 @@ impl<'a> LabelText<'a> { let mut prefix = self.pre_escaped_content().into_owned(); let suffix = suffix.pre_escaped_content(); prefix.push_str(r"\n\n"); - prefix.push_str(suffix[]); + prefix.push_str(suffix.index(&FullRange)); EscStr(prefix.into_cow()) } } @@ -676,7 +676,7 @@ mod tests { impl<'a> Labeller<'a, Node, &'a Edge> for LabelledGraph { fn graph_id(&'a self) -> Id<'a> { - Id::new(self.name[]).unwrap() + Id::new(self.name.index(&FullRange)).unwrap() } fn node_id(&'a self, n: &Node) -> Id<'a> { id_name(n) diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index df85e89efd17c..dd4291d6b51c8 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -282,7 +282,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) { // Test the literal string from args against the current filter, if there // is one. match unsafe { FILTER.as_ref() } { - Some(filter) if !filter.is_match(args.to_string()[]) => return, + Some(filter) if !filter.is_match(args.to_string().index(&FullRange)) => return, _ => {} } @@ -377,7 +377,7 @@ fn enabled(level: u32, // Search for the longest match, the vector is assumed to be pre-sorted. for directive in iter.rev() { match directive.name { - Some(ref name) if !module.starts_with(name[]) => {}, + Some(ref name) if !module.starts_with(name.index(&FullRange)) => {}, Some(..) | None => { return level <= directive.level } @@ -392,7 +392,7 @@ fn enabled(level: u32, /// `Once` primitive (and this function is called from that primitive). fn init() { let (mut directives, filter) = match os::getenv("RUST_LOG") { - Some(spec) => directive::parse_logging_spec(spec[]), + Some(spec) => directive::parse_logging_spec(spec.index(&FullRange)), None => (Vec::new(), None), }; diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 2fdba8a6c4f96..6fe995d1c5864 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -24,7 +24,7 @@ use core::num::{Float, Int}; use {Rng, Rand}; -pub use self::range::Range; +pub use self::range::Range as RandRange; pub use self::gamma::{Gamma, ChiSquared, FisherF, StudentT}; pub use self::normal::{Normal, LogNormal}; pub use self::exponential::Exp; @@ -104,7 +104,7 @@ pub struct Weighted { /// ``` pub struct WeightedChoice<'a, T:'a> { items: &'a mut [Weighted], - weight_range: Range + weight_range: RandRange } impl<'a, T: Clone> WeightedChoice<'a, T> { @@ -138,7 +138,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> { items: items, // we're likely to be generating numbers in this range // relatively often, so might as well cache it - weight_range: Range::new(0, running_total) + weight_range: RandRange::new(0, running_total) } } } diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 1038009522d67..2369c094b9f40 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -12,7 +12,7 @@ // this is surprisingly complicated to be both generic & correct -use core::prelude::*; +use core::prelude::{PartialOrd}; use core::num::Int; use Rng; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index c4dd08f9917e2..51ae3114cadc6 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -58,7 +58,7 @@ use core::prelude::*; pub use isaac::{IsaacRng, Isaac64Rng}; pub use chacha::ChaChaRng; -use distributions::{Range, IndependentSample}; +use distributions::{RandRange, IndependentSample}; use distributions::range::SampleRange; #[cfg(test)] @@ -247,7 +247,7 @@ pub trait Rng : Sized { /// ``` fn gen_range(&mut self, low: T, high: T) -> T { assert!(low < high, "Rng.gen_range called with low >= high"); - Range::new(low, high).ind_sample(self) + RandRange::new(low, high).ind_sample(self) } /// Return a bool with a 1 in n chance of true @@ -291,7 +291,7 @@ pub trait Rng : Sized { /// let mut rng = thread_rng(); /// println!("{}", rng.choose(&choices)); /// # // replace with slicing syntax when it's stable! - /// assert_eq!(rng.choose(choices.slice_to(0)), None); + /// assert_eq!(rng.choose(choices.index(&(0..0))), None); /// ``` fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> { if values.is_empty() { diff --git a/src/librbml/io.rs b/src/librbml/io.rs index de06471e65ed9..5ebec32d73384 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -95,7 +95,7 @@ impl Writer for SeekableMemWriter { // there (left), and what will be appended on the end (right) let cap = self.buf.len() - self.pos; let (left, right) = if cap <= buf.len() { - (buf[..cap], buf[cap..]) + (buf.index(&(0..cap)), buf.index(&(cap..))) } else { let result: (_, &[_]) = (buf, &[]); result diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index e57542a6d14de..ec070269fe1ae 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -65,7 +65,7 @@ impl<'doc> Doc<'doc> { } pub fn as_str_slice<'a>(&'a self) -> &'a str { - str::from_utf8(self.data[self.start..self.end]).unwrap() + str::from_utf8(self.data.index(&(self.start..self.end))).unwrap() } pub fn as_str(&self) -> String { @@ -300,7 +300,7 @@ pub mod reader { pub fn with_doc_data(d: Doc, f: F) -> T where F: FnOnce(&[u8]) -> T, { - f(d.data[d.start..d.end]) + f(d.data.index(&(d.start..d.end))) } diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs index d29a7a425c116..5803da1d3350d 100644 --- a/src/libregex/compile.rs +++ b/src/libregex/compile.rs @@ -105,7 +105,7 @@ impl Program { // This is a bit hacky since we have to skip over the initial // 'Save' instruction. let mut pre = String::with_capacity(5); - for inst in c.insts[1..].iter() { + for inst in c.insts.index(&(1..)).iter() { match *inst { OneChar(c, FLAG_EMPTY) => pre.push(c), _ => break diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index 07da86afcc971..2d46fa1143e26 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -18,6 +18,7 @@ use std::cmp; use std::fmt; use std::iter; use std::num; +use std::ops::Index; /// Static data containing Unicode ranges for general categories and scripts. use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW}; @@ -285,7 +286,7 @@ impl<'a> Parser<'a> { true => Ok(()), false => { self.err(format!("Expected {} but got EOF.", - expected)[]) + expected).index(&FullRange)) } } } @@ -294,10 +295,10 @@ impl<'a> Parser<'a> { match self.next_char() { true if self.cur() == expected => Ok(()), true => self.err(format!("Expected '{}' but got '{}'.", - expected, self.cur())[]), + expected, self.cur()).index(&FullRange)), false => { self.err(format!("Expected '{}' but got EOF.", - expected)[]) + expected).index(&FullRange)) } } } @@ -443,14 +444,14 @@ impl<'a> Parser<'a> { Literal(c3, _) => c2 = c3, // allow literal escapes below ast => return self.err(format!("Expected a literal, but got {}.", - ast)[]), + ast).index(&FullRange)), } } if c2 < c { return self.err(format!("Invalid character class \ range '{}-{}'", c, - c2)[]) + c2).index(&FullRange)) } ranges.push((c, self.cur())) } else { @@ -488,7 +489,7 @@ impl<'a> Parser<'a> { FLAG_EMPTY }; let name = self.slice(name_start, closer - 1); - match find_class(ASCII_CLASSES, name[]) { + match find_class(ASCII_CLASSES, name.index(&FullRange)) { None => None, Some(ranges) => { self.chari = closer; @@ -513,18 +514,18 @@ impl<'a> Parser<'a> { return self.err(format!("No closing brace for counted \ repetition starting at position \ {}.", - start)[]) + start).index(&FullRange)) } }; self.chari = closer; let greed = try!(self.get_next_greedy()); - let inner = self.chars[start+1..closer].iter().cloned() + let inner = self.chars.index(&((start+1)..closer)).iter().cloned() .collect::(); // Parse the min and max values from the regex. let (mut min, mut max): (uint, Option); if !inner.contains(",") { - min = try!(self.parse_uint(inner[])); + min = try!(self.parse_uint(inner.index(&FullRange))); max = Some(min); } else { let pieces: Vec<&str> = inner.splitn(1, ',').collect(); @@ -546,19 +547,19 @@ impl<'a> Parser<'a> { if min > MAX_REPEAT { return self.err(format!( "{} exceeds maximum allowed repetitions ({})", - min, MAX_REPEAT)[]); + min, MAX_REPEAT).index(&FullRange)); } if max.is_some() { let m = max.unwrap(); if m > MAX_REPEAT { return self.err(format!( "{} exceeds maximum allowed repetitions ({})", - m, MAX_REPEAT)[]); + m, MAX_REPEAT).index(&FullRange)); } if m < min { return self.err(format!( "Max repetitions ({}) cannot be smaller than min \ - repetitions ({}).", m, min)[]); + repetitions ({}).", m, min).index(&FullRange)); } } @@ -622,7 +623,7 @@ impl<'a> Parser<'a> { Ok(AstClass(ranges, flags)) } _ => { - self.err(format!("Invalid escape sequence '\\\\{}'", c)[]) + self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange)) } } } @@ -642,7 +643,7 @@ impl<'a> Parser<'a> { Some(i) => i, None => return self.err(format!( "Missing '}}' for unclosed '{{' at position {}", - self.chari)[]), + self.chari).index(&FullRange)), }; if closer - self.chari + 1 == 0 { return self.err("No Unicode class name found.") @@ -656,10 +657,10 @@ impl<'a> Parser<'a> { name = self.slice(self.chari + 1, self.chari + 2); self.chari += 1; } - match find_class(UNICODE_CLASSES, name[]) { + match find_class(UNICODE_CLASSES, name.index(&FullRange)) { None => { return self.err(format!("Could not find Unicode class '{}'", - name)[]) + name).index(&FullRange)) } Some(ranges) => { Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE))) @@ -682,11 +683,11 @@ impl<'a> Parser<'a> { } } let s = self.slice(start, end); - match num::from_str_radix::(s[], 8) { + match num::from_str_radix::(s.index(&FullRange), 8) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => { self.err(format!("Could not parse '{}' as octal number.", - s)[]) + s).index(&FullRange)) } } } @@ -704,12 +705,12 @@ impl<'a> Parser<'a> { None => { return self.err(format!("Missing '}}' for unclosed \ '{{' at position {}", - start)[]) + start).index(&FullRange)) } Some(i) => i, }; self.chari = closer; - self.parse_hex_digits(self.slice(start, closer)[]) + self.parse_hex_digits(self.slice(start, closer).index(&FullRange)) } // Parses a two-digit hex number. @@ -729,7 +730,7 @@ impl<'a> Parser<'a> { match num::from_str_radix::(s, 16) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => { - self.err(format!("Could not parse '{}' as hex number.", s)[]) + self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange)) } } } @@ -755,7 +756,7 @@ impl<'a> Parser<'a> { } if self.names.contains(&name) { return self.err(format!("Duplicate capture group name '{}'.", - name)[]) + name).index(&FullRange)) } self.names.push(name.clone()); self.chari = closer; @@ -789,7 +790,7 @@ impl<'a> Parser<'a> { if sign < 0 { return self.err(format!( "Cannot negate flags twice in '{}'.", - self.slice(start, self.chari + 1))[]) + self.slice(start, self.chari + 1)).index(&FullRange)) } sign = -1; saw_flag = false; @@ -800,7 +801,7 @@ impl<'a> Parser<'a> { if !saw_flag { return self.err(format!( "A valid flag does not follow negation in '{}'", - self.slice(start, self.chari + 1))[]) + self.slice(start, self.chari + 1)).index(&FullRange)) } flags = flags ^ flags; } @@ -812,7 +813,7 @@ impl<'a> Parser<'a> { return Ok(()) } _ => return self.err(format!( - "Unrecognized flag '{}'.", self.cur())[]), + "Unrecognized flag '{}'.", self.cur()).index(&FullRange)), } } } @@ -910,7 +911,7 @@ impl<'a> Parser<'a> { Some(i) => Ok(i), None => { self.err(format!("Expected an unsigned integer but got '{}'.", - s)[]) + s).index(&FullRange)) } } } @@ -920,7 +921,7 @@ impl<'a> Parser<'a> { Some(c) => Ok(c), None => { self.err(format!("Could not decode '{}' to unicode \ - character.", n)[]) + character.", n).index(&FullRange)) } } } @@ -953,7 +954,7 @@ impl<'a> Parser<'a> { } fn slice(&self, start: uint, end: uint) -> String { - self.chars[start..end].iter().cloned().collect() + self.chars.index(&(start..end)).iter().cloned().collect() } } diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 1840a3343e63c..cb2690ce80ca1 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -238,19 +238,19 @@ impl Regex { } let (s, e) = cap.pos(0).unwrap(); // captures only reports matches - new.push_str(text[last_match..s]); - new.push_str(rep.reg_replace(&cap)[]); + new.push_str(text.index(&(last_match..s))); + new.push_str(rep.reg_replace(&cap).index(&FullRange)); last_match = e; } - new.push_str(text[last_match..text.len()]); + new.push_str(text.index(&(last_match..text.len()))); return new; } /// Returns the original string of this regex. pub fn as_str<'a>(&'a self) -> &'a str { match *self { - Dynamic(ExDynamic { ref original, .. }) => original[], - Native(ExNative { ref original, .. }) => original[], + Dynamic(ExDynamic { ref original, .. }) => original.index(&FullRange), + Native(ExNative { ref original, .. }) => original.index(&FullRange), } } @@ -347,13 +347,13 @@ impl<'r, 't> Iterator for RegexSplits<'r, 't> { if self.last >= text.len() { None } else { - let s = text[self.last..text.len()]; + let s = text.index(&(self.last..text.len())); self.last = text.len(); Some(s) } } Some((s, e)) => { - let matched = text[self.last..s]; + let matched = text.index(&(self.last..s)); self.last = e; Some(matched) } @@ -384,7 +384,7 @@ impl<'r, 't> Iterator for RegexSplitsN<'r, 't> { } else { self.cur += 1; if self.cur >= self.limit { - Some(text[self.splits.last..text.len()]) + Some(text.index(&(self.splits.last..text.len()))) } else { self.splits.next() } @@ -517,7 +517,7 @@ impl<'t> Captures<'t> { }) }); let re = Regex::new(r"\$\$").unwrap(); - re.replace_all(text[], NoExpand("$")) + re.replace_all(text.index(&FullRange), NoExpand("$")) } /// Returns the number of captured groups. diff --git a/src/libregex/test/matches.rs b/src/libregex/test/matches.rs index 7508f4c50a2c3..b422ac668ca8d 100644 --- a/src/libregex/test/matches.rs +++ b/src/libregex/test/matches.rs @@ -121,7 +121,7 @@ mat!{match_basic_110, r"a[b-d]", r"aac", Some((1, 3))} mat!{match_basic_111, r"a[-b]", r"a-", Some((0, 2))} mat!{match_basic_112, r"a[b-]", r"a-", Some((0, 2))} mat!{match_basic_113, r"a]", r"a]", Some((0, 2))} -mat!{match_basic_114, r"a[]]b", r"a]b", Some((0, 3))} +mat!{match_basic_114, r"a.index(&FullRange)]b", r"a]b", Some((0, 3))} mat!{match_basic_115, r"a[^bc]d", r"aed", Some((0, 3))} mat!{match_basic_116, r"a[^-b]c", r"adc", Some((0, 3))} mat!{match_basic_117, r"a[^]b]c", r"adc", Some((0, 3))} diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs index 914167019d209..04c430da4d290 100644 --- a/src/libregex/vm.rs +++ b/src/libregex/vm.rs @@ -152,7 +152,7 @@ impl<'r, 't> Nfa<'r, 't> { // out early. if self.prog.prefix.len() > 0 && clist.size == 0 { let needle = self.prog.prefix.as_bytes(); - let haystack = self.input.as_bytes()[self.ic..]; + let haystack = self.input.as_bytes().index(&(self.ic..)); match find_prefix(needle, haystack) { None => break, Some(i) => { @@ -503,7 +503,8 @@ impl Threads { #[inline] fn groups<'r>(&'r mut self, i: uint) -> &'r mut [Option] { - self.queue[i].groups.as_mut_slice() + let q = &mut self.queue[i]; + q.groups.as_mut_slice() } } diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 425e34cd9f042..1d446817c189d 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -506,7 +506,7 @@ impl BoxPointers { if n_uniq > 0 { let s = ty_to_string(cx.tcx, ty); let m = format!("type uses owned (Box type) pointers: {}", s); - cx.span_lint(BOX_POINTERS, span, m[]); + cx.span_lint(BOX_POINTERS, span, m.index(&FullRange)); } } } @@ -586,7 +586,7 @@ impl LintPass for RawPointerDerive { } fn check_item(&mut self, cx: &Context, item: &ast::Item) { - if !attr::contains_name(item.attrs[], "automatically_derived") { + if !attr::contains_name(item.attrs.index(&FullRange), "automatically_derived") { return } let did = match item.node { @@ -769,11 +769,11 @@ impl LintPass for UnusedResults { ty::ty_enum(did, _) => { if ast_util::is_local(did) { if let ast_map::NodeItem(it) = cx.tcx.map.get(did.node) { - warned |= check_must_use(cx, it.attrs[], s.span); + warned |= check_must_use(cx, it.attrs.index(&FullRange), s.span); } } else { csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| { - warned |= check_must_use(cx, attrs[], s.span); + warned |= check_must_use(cx, attrs.index(&FullRange), s.span); }); } } @@ -795,7 +795,7 @@ impl LintPass for UnusedResults { msg.push_str(s.get()); } } - cx.span_lint(UNUSED_MUST_USE, sp, msg[]); + cx.span_lint(UNUSED_MUST_USE, sp, msg.index(&FullRange)); return true; } } @@ -841,7 +841,7 @@ impl NonCamelCaseTypes { } else { format!("{} `{}` should have a camel case name such as `{}`", sort, s, c) }; - cx.span_lint(NON_CAMEL_CASE_TYPES, span, m[]); + cx.span_lint(NON_CAMEL_CASE_TYPES, span, m.index(&FullRange)); } } } @@ -981,7 +981,7 @@ impl NonSnakeCase { if !is_snake_case(ident) { cx.span_lint(NON_SNAKE_CASE, span, format!("{} `{}` should have a snake case name such as `{}`", - sort, s, to_snake_case(s.get()))[]); + sort, s, to_snake_case(s.get())).index(&FullRange)); } } } @@ -1068,7 +1068,7 @@ impl LintPass for NonUpperCaseGlobals { format!("static constant `{}` should have an uppercase name \ such as `{}`", s.get(), s.get().chars().map(|c| c.to_uppercase()) - .collect::()[])[]); + .collect::().index(&FullRange)).index(&FullRange)); } } _ => {} @@ -1085,7 +1085,7 @@ impl LintPass for NonUpperCaseGlobals { format!("static constant in pattern `{}` should have an uppercase \ name such as `{}`", s.get(), s.get().chars().map(|c| c.to_uppercase()) - .collect::()[])[]); + .collect::().index(&FullRange)).index(&FullRange)); } } _ => {} @@ -1110,7 +1110,7 @@ impl UnusedParens { if !necessary { cx.span_lint(UNUSED_PARENS, value.span, format!("unnecessary parentheses around {}", - msg)[]) + msg).index(&FullRange)) } } @@ -1212,7 +1212,7 @@ impl LintPass for UnusedImportBraces { let m = format!("braces around {} is unnecessary", token::get_ident(*name).get()); cx.span_lint(UNUSED_IMPORT_BRACES, view_item.span, - m[]); + m.index(&FullRange)); }, _ => () } @@ -1251,7 +1251,7 @@ impl LintPass for NonShorthandFieldPatterns { if ident.node.as_str() == fieldpat.node.ident.as_str() { cx.span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, format!("the `{}:` in this pattern is redundant and can \ - be removed", ident.node.as_str())[]) + be removed", ident.node.as_str()).index(&FullRange)) } } } @@ -1355,7 +1355,7 @@ impl LintPass for UnusedMut { fn check_expr(&mut self, cx: &Context, e: &ast::Expr) { if let ast::ExprMatch(_, ref arms, _) = e.node { for a in arms.iter() { - self.check_unused_mut_pat(cx, a.pats[]) + self.check_unused_mut_pat(cx, a.pats.index(&FullRange)) } } } @@ -1476,7 +1476,7 @@ impl MissingDoc { }); if !has_doc { cx.span_lint(MISSING_DOCS, sp, - format!("missing documentation for {}", desc)[]); + format!("missing documentation for {}", desc).index(&FullRange)); } } } @@ -1490,7 +1490,7 @@ impl LintPass for MissingDoc { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && match attr.meta_item_list() { None => false, - Some(l) => attr::contains_name(l[], "hidden"), + Some(l) => attr::contains_name(l.index(&FullRange), "hidden"), } }); self.doc_hidden_stack.push(doc_hidden); @@ -1512,7 +1512,7 @@ impl LintPass for MissingDoc { } fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) { - self.check_missing_docs_attrs(cx, None, krate.attrs[], + self.check_missing_docs_attrs(cx, None, krate.attrs.index(&FullRange), krate.span, "crate"); } @@ -1526,7 +1526,7 @@ impl LintPass for MissingDoc { ast::ItemTy(..) => "a type alias", _ => return }; - self.check_missing_docs_attrs(cx, Some(it.id), it.attrs[], + self.check_missing_docs_attrs(cx, Some(it.id), it.attrs.index(&FullRange), it.span, desc); } @@ -1539,13 +1539,13 @@ impl LintPass for MissingDoc { // Otherwise, doc according to privacy. This will also check // doc for default methods defined on traits. - self.check_missing_docs_attrs(cx, Some(m.id), m.attrs[], + self.check_missing_docs_attrs(cx, Some(m.id), m.attrs.index(&FullRange), m.span, "a method"); } } fn check_ty_method(&mut self, cx: &Context, tm: &ast::TypeMethod) { - self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs[], + self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs.index(&FullRange), tm.span, "a type method"); } @@ -1555,14 +1555,14 @@ impl LintPass for MissingDoc { let cur_struct_def = *self.struct_def_stack.last() .expect("empty struct_def_stack"); self.check_missing_docs_attrs(cx, Some(cur_struct_def), - sf.node.attrs[], sf.span, + sf.node.attrs.index(&FullRange), sf.span, "a struct field") } } } fn check_variant(&mut self, cx: &Context, v: &ast::Variant, _: &ast::Generics) { - self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs[], + self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs.index(&FullRange), v.span, "a variant"); assert!(!self.in_variant); self.in_variant = true; @@ -1674,7 +1674,7 @@ impl Stability { _ => format!("use of {} item", label) }; - cx.span_lint(lint, span, msg[]); + cx.span_lint(lint, span, msg.index(&FullRange)); } fn is_internal(&self, cx: &Context, span: Span) -> bool { diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 5c0fd8944368f..fa451e03ab938 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -104,7 +104,7 @@ impl LintStore { } pub fn get_lints<'t>(&'t self) -> &'t [(&'static Lint, bool)] { - self.lints[] + self.lints.index(&FullRange) } pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec, bool)> { @@ -124,11 +124,11 @@ impl LintStore { match (sess, from_plugin) { // We load builtin lints first, so a duplicate is a compiler bug. // Use early_error when handling -W help with no crate. - (None, _) => early_error(msg[]), - (Some(sess), false) => sess.bug(msg[]), + (None, _) => early_error(msg.index(&FullRange)), + (Some(sess), false) => sess.bug(msg.index(&FullRange)), // A duplicate name from a plugin is a user error. - (Some(sess), true) => sess.err(msg[]), + (Some(sess), true) => sess.err(msg.index(&FullRange)), } } @@ -149,11 +149,11 @@ impl LintStore { match (sess, from_plugin) { // We load builtin lints first, so a duplicate is a compiler bug. // Use early_error when handling -W help with no crate. - (None, _) => early_error(msg[]), - (Some(sess), false) => sess.bug(msg[]), + (None, _) => early_error(msg.index(&FullRange)), + (Some(sess), false) => sess.bug(msg.index(&FullRange)), // A duplicate name from a plugin is a user error. - (Some(sess), true) => sess.err(msg[]), + (Some(sess), true) => sess.err(msg.index(&FullRange)), } } } @@ -267,8 +267,8 @@ impl LintStore { let warning = format!("lint {} has been renamed to {}", lint_name, new_name); match span { - Some(span) => sess.span_warn(span, warning[]), - None => sess.warn(warning[]), + Some(span) => sess.span_warn(span, warning.index(&FullRange)), + None => sess.warn(warning.index(&FullRange)), }; Some(lint_id) } @@ -278,13 +278,13 @@ impl LintStore { pub fn process_command_line(&mut self, sess: &Session) { for &(ref lint_name, level) in sess.opts.lint_opts.iter() { - match self.find_lint(lint_name[], sess, None) { + match self.find_lint(lint_name.index(&FullRange), sess, None) { Some(lint_id) => self.set_level(lint_id, (level, CommandLine)), None => { match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone())) .collect::>>() - .get(lint_name[]) { + .get(lint_name.index(&FullRange)) { Some(v) => { v.iter() .map(|lint_id: &LintId| @@ -292,7 +292,7 @@ impl LintStore { .collect::>(); } None => sess.err(format!("unknown {} flag: {}", - level.as_str(), lint_name)[]), + level.as_str(), lint_name).index(&FullRange)), } } } @@ -403,10 +403,10 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint, if level == Forbid { level = Deny; } match (level, span) { - (Warn, Some(sp)) => sess.span_warn(sp, msg[]), - (Warn, None) => sess.warn(msg[]), - (Deny, Some(sp)) => sess.span_err(sp, msg[]), - (Deny, None) => sess.err(msg[]), + (Warn, Some(sp)) => sess.span_warn(sp, msg.index(&FullRange)), + (Warn, None) => sess.warn(msg.index(&FullRange)), + (Deny, Some(sp)) => sess.span_err(sp, msg.index(&FullRange)), + (Deny, None) => sess.err(msg.index(&FullRange)), _ => sess.bug("impossible level in raw_emit_lint"), } @@ -499,7 +499,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> { None => { self.span_lint(builtin::UNKNOWN_LINTS, span, format!("unknown `{}` attribute: `{}`", - level.as_str(), lint_name)[]); + level.as_str(), lint_name).index(&FullRange)); continue; } } @@ -515,7 +515,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> { self.tcx.sess.span_err(span, format!("{}({}) overruled by outer forbid({})", level.as_str(), lint_name, - lint_name)[]); + lint_name).index(&FullRange)); } else if now != level { let src = self.lints.get_level_source(lint_id).1; self.level_stack.push((lint_id, (now, src))); @@ -550,7 +550,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { fn visit_item(&mut self, it: &ast::Item) { - self.with_lint_attrs(it.attrs[], |cx| { + self.with_lint_attrs(it.attrs.index(&FullRange), |cx| { run_lints!(cx, check_item, it); cx.visit_ids(|v| v.visit_item(it)); visit::walk_item(cx, it); @@ -558,14 +558,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_foreign_item(&mut self, it: &ast::ForeignItem) { - self.with_lint_attrs(it.attrs[], |cx| { + self.with_lint_attrs(it.attrs.index(&FullRange), |cx| { run_lints!(cx, check_foreign_item, it); visit::walk_foreign_item(cx, it); }) } fn visit_view_item(&mut self, i: &ast::ViewItem) { - self.with_lint_attrs(i.attrs[], |cx| { + self.with_lint_attrs(i.attrs.index(&FullRange), |cx| { run_lints!(cx, check_view_item, i); cx.visit_ids(|v| v.visit_view_item(i)); visit::walk_view_item(cx, i); @@ -591,7 +591,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { body: &'v ast::Block, span: Span, id: ast::NodeId) { match fk { visit::FkMethod(_, _, m) => { - self.with_lint_attrs(m.attrs[], |cx| { + self.with_lint_attrs(m.attrs.index(&FullRange), |cx| { run_lints!(cx, check_fn, fk, decl, body, span, id); cx.visit_ids(|v| { v.visit_fn(fk, decl, body, span, id); @@ -607,7 +607,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_ty_method(&mut self, t: &ast::TypeMethod) { - self.with_lint_attrs(t.attrs[], |cx| { + self.with_lint_attrs(t.attrs.index(&FullRange), |cx| { run_lints!(cx, check_ty_method, t); visit::walk_ty_method(cx, t); }) @@ -624,14 +624,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { } fn visit_struct_field(&mut self, s: &ast::StructField) { - self.with_lint_attrs(s.node.attrs[], |cx| { + self.with_lint_attrs(s.node.attrs.index(&FullRange), |cx| { run_lints!(cx, check_struct_field, s); visit::walk_struct_field(cx, s); }) } fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) { - self.with_lint_attrs(v.node.attrs[], |cx| { + self.with_lint_attrs(v.node.attrs.index(&FullRange), |cx| { run_lints!(cx, check_variant, v, g); visit::walk_variant(cx, v, g); run_lints!(cx, check_variant_post, v, g); @@ -725,7 +725,7 @@ impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> { None => {} Some(lints) => { for (lint_id, span, msg) in lints.into_iter() { - self.span_lint(lint_id.lint, span, msg[]) + self.span_lint(lint_id.lint, span, msg.index(&FullRange)) } } } @@ -771,7 +771,7 @@ pub fn check_crate(tcx: &ty::ctxt, let mut cx = Context::new(tcx, krate, exported_items); // Visit the whole crate. - cx.with_lint_attrs(krate.attrs[], |cx| { + cx.with_lint_attrs(krate.attrs.index(&FullRange), |cx| { cx.visit_id(ast::CRATE_NODE_ID); cx.visit_ids(|v| { v.visited_outermost = true; @@ -791,7 +791,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)[]) + lint.as_str(), tcx.map.node_to_string(*id), *msg).index(&FullRange)) } } diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index b44520e28527b..08d19dcb60730 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -65,7 +65,8 @@ fn dump_crates(cstore: &CStore) { } fn should_link(i: &ast::ViewItem) -> bool { - !attr::contains_name(i.attrs[], "no_link") + !attr::contains_name(i.attrs.index(&FullRange), "no_link") + } struct CrateInfo { @@ -89,7 +90,7 @@ pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option) { for c in s.chars() { if c.is_alphanumeric() { continue } if c == '_' || c == '-' { continue } - err(format!("invalid character `{}` in crate name: `{}`", c, s)[]); + err(format!("invalid character `{}` in crate name: `{}`", c, s).index(&FullRange)); } match sess { Some(sess) => sess.abort_if_errors(), @@ -97,6 +98,7 @@ pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option) { } } + fn register_native_lib(sess: &Session, span: Option, name: String, @@ -187,8 +189,8 @@ impl<'a> CrateReader<'a> { match self.extract_crate_info(i) { Some(info) => { let (cnum, _, _) = self.resolve_crate(&None, - info.ident[], - info.name[], + info.ident.index(&FullRange), + info.name.index(&FullRange), None, i.span, PathKind::Crate); @@ -433,8 +435,8 @@ impl<'a> CrateReader<'a> { decoder::get_crate_deps(cdata).iter().map(|dep| { debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash); let (local_cnum, _, _) = self.resolve_crate(root, - dep.name[], - dep.name[], + dep.name.index(&FullRange), + dep.name.index(&FullRange), Some(&dep.hash), span, PathKind::Dependency); @@ -445,7 +447,7 @@ impl<'a> CrateReader<'a> { pub fn read_plugin_metadata<'b>(&'b mut self, vi: &'b ast::ViewItem) -> PluginMetadata<'b> { let info = self.extract_crate_info(vi).unwrap(); - let target_triple = self.sess.opts.target_triple[]; + let target_triple = self.sess.opts.target_triple.index(&FullRange); let is_cross = target_triple != config::host_triple(); let mut should_link = info.should_link && !is_cross; let mut target_only = false; @@ -454,8 +456,8 @@ impl<'a> CrateReader<'a> { let mut load_ctxt = loader::Context { sess: self.sess, span: vi.span, - ident: ident[], - crate_name: name[], + ident: ident.index(&FullRange), + crate_name: name.index(&FullRange), hash: None, filesearch: self.sess.host_filesearch(PathKind::Crate), triple: config::host_triple(), @@ -480,11 +482,11 @@ impl<'a> CrateReader<'a> { }; let dylib = library.dylib.clone(); - let register = should_link && self.existing_match(info.name[], None).is_none(); + let register = should_link && self.existing_match(info.name.as_slice(), None).is_none(); let metadata = if register { // Register crate now to avoid double-reading metadata - let (_, cmd, _) = self.register_crate(&None, info.ident[], - info.name[], vi.span, library); + let (_, cmd, _) = self.register_crate(&None, info.ident.index(&FullRange), + info.name.index(&FullRange), vi.span, library); PMDSource::Registered(cmd) } else { // Not registering the crate; just hold on to the metadata @@ -505,8 +507,8 @@ impl<'a> CrateReader<'a> { impl<'a> PluginMetadata<'a> { /// Read exported macros pub fn exported_macros(&self) -> Vec { - let imported_from = Some(token::intern(self.info.ident[]).ident()); - let source_name = format!("<{} macros>", self.info.ident[]); + let imported_from = Some(token::intern(self.info.ident.index(&FullRange)).ident()); + let source_name = format!("<{} macros>", self.info.ident.index(&FullRange)); let mut macros = vec![]; decoder::each_exported_macro(self.metadata.as_slice(), &*self.sess.cstore.intr, @@ -548,7 +550,7 @@ impl<'a> PluginMetadata<'a> { self.info.ident, config::host_triple(), self.sess.opts.target_triple); - self.sess.span_err(self.vi_span, message[]); + self.sess.span_err(self.vi_span, message.index(&FullRange)); self.sess.abort_if_errors(); } @@ -561,7 +563,7 @@ impl<'a> PluginMetadata<'a> { let message = format!("plugin crate `{}` only found in rlib format, \ but must be available in dylib format", self.info.ident); - self.sess.span_err(self.vi_span, message[]); + self.sess.span_err(self.vi_span, message.index(&FullRange)); // No need to abort because the loading code will just ignore this // empty dylib. None diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 1401a7d4a1a6e..9249bce276edd 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -95,7 +95,7 @@ pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec // FIXME #1920: This path is not always correct if the crate is not linked // into the root namespace. - let mut r = vec![ast_map::PathMod(token::intern(cdata.name[]))]; + let mut r = vec![ast_map::PathMod(token::intern(cdata.name.index(&FullRange)))]; r.push_all(path.as_slice()); r } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index ed0a1f6211b16..25ce8a6889d0e 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -75,7 +75,7 @@ fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option(item_id: ast::NodeId, items: rbml::Doc<'a>) -> Option> { fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool { return u64_from_be_bytes( - bytes[0u..4u], 0u, 4u) as ast::NodeId + bytes.index(&(0u..4u)), 0u, 4u) as ast::NodeId == item_id; } lookup_hash(items, @@ -1191,7 +1191,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec { } reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| { let name = docstr(depdoc, tag_crate_dep_crate_name); - let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash)[]); + let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash).index(&FullRange)); deps.push(CrateDep { cnum: crate_num, name: name, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index e4226ddde85b6..592fbe4d64ec7 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -95,7 +95,7 @@ fn encode_impl_type_basename(rbml_w: &mut Encoder, name: ast::Ident) { } pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) { - rbml_w.wr_tagged_str(tag_def_id, def_to_string(id)[]); + rbml_w.wr_tagged_str(tag_def_id, def_to_string(id).index(&FullRange)); } #[derive(Clone)] @@ -154,7 +154,7 @@ fn encode_variant_id(rbml_w: &mut Encoder, vid: DefId) { rbml_w.end_tag(); rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(s[]); + rbml_w.wr_str(s.index(&FullRange)); rbml_w.end_tag(); } @@ -264,7 +264,7 @@ fn encode_symbol(ecx: &EncodeContext, } None => { ecx.diag.handler().bug( - format!("encode_symbol: id not found {}", id)[]); + format!("encode_symbol: id not found {}", id).index(&FullRange)); } } rbml_w.end_tag(); @@ -332,8 +332,8 @@ fn encode_enum_variant_info(ecx: &EncodeContext, encode_name(rbml_w, variant.node.name.name); encode_parent_item(rbml_w, local_def(id)); encode_visibility(rbml_w, variant.node.vis); - encode_attributes(rbml_w, variant.node.attrs[]); - encode_repr_attrs(rbml_w, ecx, variant.node.attrs[]); + encode_attributes(rbml_w, variant.node.attrs.index(&FullRange)); + encode_repr_attrs(rbml_w, ecx, variant.node.attrs.index(&FullRange)); let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id)); encode_stability(rbml_w, stab); @@ -344,9 +344,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let fields = ty::lookup_struct_fields(ecx.tcx, def_id); let idx = encode_info_for_struct(ecx, rbml_w, - fields[], + fields.index(&FullRange), index); - encode_struct_fields(rbml_w, fields[], def_id); + encode_struct_fields(rbml_w, fields.index(&FullRange), def_id); encode_index(rbml_w, idx, write_i64); } } @@ -386,12 +386,12 @@ fn encode_reexported_static_method(rbml_w: &mut Encoder, exp.name, token::get_name(method_name)); rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.start_tag(tag_items_data_item_reexport_def_id); - rbml_w.wr_str(def_to_string(method_def_id)[]); + rbml_w.wr_str(def_to_string(method_def_id).index(&FullRange)); rbml_w.end_tag(); rbml_w.start_tag(tag_items_data_item_reexport_name); rbml_w.wr_str(format!("{}::{}", exp.name, - token::get_name(method_name))[]); + token::get_name(method_name)).index(&FullRange)); rbml_w.end_tag(); rbml_w.end_tag(); } @@ -529,7 +529,7 @@ fn encode_reexports(ecx: &EncodeContext, id); rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.start_tag(tag_items_data_item_reexport_def_id); - rbml_w.wr_str(def_to_string(exp.def_id)[]); + rbml_w.wr_str(def_to_string(exp.def_id).index(&FullRange)); rbml_w.end_tag(); rbml_w.start_tag(tag_items_data_item_reexport_name); rbml_w.wr_str(exp.name.as_str()); @@ -562,13 +562,13 @@ fn encode_info_for_mod(ecx: &EncodeContext, // Encode info about all the module children. for item in md.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(item.id))[]); + rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange)); rbml_w.end_tag(); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(def_to_string(local_def( - auxiliary_node_id))[]); + auxiliary_node_id)).index(&FullRange)); rbml_w.end_tag(); true }); @@ -580,7 +580,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, did, ecx.tcx.map.node_to_string(did)); rbml_w.start_tag(tag_mod_impl); - rbml_w.wr_str(def_to_string(local_def(did))[]); + rbml_w.wr_str(def_to_string(local_def(did)).index(&FullRange)); rbml_w.end_tag(); } } @@ -615,7 +615,7 @@ fn encode_visibility(rbml_w: &mut Encoder, visibility: ast::Visibility) { ast::Public => 'y', ast::Inherited => 'i', }; - rbml_w.wr_str(ch.to_string()[]); + rbml_w.wr_str(ch.to_string().index(&FullRange)); rbml_w.end_tag(); } @@ -627,7 +627,7 @@ fn encode_unboxed_closure_kind(rbml_w: &mut Encoder, ty::FnMutUnboxedClosureKind => 'm', ty::FnOnceUnboxedClosureKind => 'o', }; - rbml_w.wr_str(ch.to_string()[]); + rbml_w.wr_str(ch.to_string().index(&FullRange)); rbml_w.end_tag(); } @@ -788,7 +788,7 @@ fn encode_generics<'a, 'tcx>(rbml_w: &mut Encoder, rbml_w.end_tag(); rbml_w.wr_tagged_str(tag_region_param_def_def_id, - def_to_string(param.def_id)[]); + def_to_string(param.def_id).index(&FullRange)); rbml_w.wr_tagged_u64(tag_region_param_def_space, param.space.to_uint() as u64); @@ -864,9 +864,9 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_path(rbml_w, impl_path.chain(Some(elem).into_iter())); match ast_item_opt { Some(&ast::MethodImplItem(ref ast_method)) => { - encode_attributes(rbml_w, ast_method.attrs[]); + encode_attributes(rbml_w, ast_method.attrs.index(&FullRange)); let any_types = !pty.generics.types.is_empty(); - if any_types || is_default_impl || should_inline(ast_method.attrs[]) { + if any_types || is_default_impl || should_inline(ast_method.attrs.index(&FullRange)) { encode_inlined_item(ecx, rbml_w, IIImplItemRef(local_def(parent_id), ast_item_opt.unwrap())); } @@ -912,7 +912,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext, match typedef_opt { None => {} Some(typedef) => { - encode_attributes(rbml_w, typedef.attrs[]); + encode_attributes(rbml_w, typedef.attrs.index(&FullRange)); encode_type(ecx, rbml_w, ty::node_id_to_type(ecx.tcx, typedef.id)); } @@ -1046,7 +1046,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_path(rbml_w, path); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); - encode_attributes(rbml_w, item.attrs[]); + encode_attributes(rbml_w, item.attrs.index(&FullRange)); rbml_w.end_tag(); } ast::ItemConst(_, _) => { @@ -1072,8 +1072,8 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); encode_path(rbml_w, path); - encode_attributes(rbml_w, item.attrs[]); - if tps_len > 0u || should_inline(item.attrs[]) { + encode_attributes(rbml_w, item.attrs.index(&FullRange)); + if tps_len > 0u || should_inline(item.attrs.index(&FullRange)) { encode_inlined_item(ecx, rbml_w, IIItemRef(item)); } if tps_len == 0 { @@ -1089,7 +1089,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_info_for_mod(ecx, rbml_w, m, - item.attrs[], + item.attrs.index(&FullRange), item.id, path, item.ident, @@ -1106,7 +1106,7 @@ fn encode_info_for_item(ecx: &EncodeContext, // Encode all the items in this module. for foreign_item in fm.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(foreign_item.id))[]); + rbml_w.wr_str(def_to_string(local_def(foreign_item.id)).index(&FullRange)); rbml_w.end_tag(); } encode_visibility(rbml_w, vis); @@ -1134,8 +1134,8 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_item_variances(rbml_w, ecx, item.id); encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs[]); - encode_repr_attrs(rbml_w, ecx, item.attrs[]); + encode_attributes(rbml_w, item.attrs.index(&FullRange)); + encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange)); for v in (*enum_definition).variants.iter() { encode_variant_id(rbml_w, local_def(v.node.id)); } @@ -1152,7 +1152,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_enum_variant_info(ecx, rbml_w, item.id, - (*enum_definition).variants[], + (*enum_definition).variants.index(&FullRange), index); } ast::ItemStruct(ref struct_def, _) => { @@ -1164,7 +1164,7 @@ fn encode_info_for_item(ecx: &EncodeContext, class itself */ let idx = encode_info_for_struct(ecx, rbml_w, - fields[], + fields.index(&FullRange), index); /* Index the class*/ @@ -1178,16 +1178,16 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_item_variances(rbml_w, ecx, item.id); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs[]); + encode_attributes(rbml_w, item.attrs.index(&FullRange)); encode_path(rbml_w, path.clone()); encode_stability(rbml_w, stab); encode_visibility(rbml_w, vis); - encode_repr_attrs(rbml_w, ecx, item.attrs[]); + encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange)); /* Encode def_ids for each field and method for methods, write all the stuff get_trait_method needs to know*/ - encode_struct_fields(rbml_w, fields[], def_id); + encode_struct_fields(rbml_w, fields.index(&FullRange), def_id); encode_inlined_item(ecx, rbml_w, IIItemRef(item)); @@ -1219,7 +1219,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_family(rbml_w, 'i'); encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs[]); + encode_attributes(rbml_w, item.attrs.index(&FullRange)); encode_unsafety(rbml_w, unsafety); encode_polarity(rbml_w, polarity); match ty.node { @@ -1323,7 +1323,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_generics(rbml_w, ecx, &trait_def.generics, tag_item_generics); encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref); encode_name(rbml_w, item.ident.name); - encode_attributes(rbml_w, item.attrs[]); + encode_attributes(rbml_w, item.attrs.index(&FullRange)); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() { @@ -1341,7 +1341,7 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(method_def_id.def_id())[]); + rbml_w.wr_str(def_to_string(method_def_id.def_id()).index(&FullRange)); rbml_w.end_tag(); } encode_path(rbml_w, path.clone()); @@ -1433,14 +1433,14 @@ fn encode_info_for_item(ecx: &EncodeContext, }; match trait_item { &ast::RequiredMethod(ref m) => { - encode_attributes(rbml_w, m.attrs[]); + encode_attributes(rbml_w, m.attrs.index(&FullRange)); encode_trait_item(rbml_w); encode_item_sort(rbml_w, 'r'); encode_method_argument_names(rbml_w, &*m.decl); } &ast::ProvidedMethod(ref m) => { - encode_attributes(rbml_w, m.attrs[]); + encode_attributes(rbml_w, m.attrs.index(&FullRange)); encode_trait_item(rbml_w); encode_item_sort(rbml_w, 'p'); encode_inlined_item(ecx, rbml_w, IITraitItemRef(def_id, trait_item)); @@ -1449,7 +1449,7 @@ fn encode_info_for_item(ecx: &EncodeContext, &ast::TypeTraitItem(ref associated_type) => { encode_attributes(rbml_w, - associated_type.attrs[]); + associated_type.attrs.index(&FullRange)); encode_item_sort(rbml_w, 't'); } } @@ -1603,7 +1603,7 @@ fn encode_index(rbml_w: &mut Encoder, index: Vec>, mut write_fn: let mut buckets: Vec>> = range(0, 256u16).map(|_| Vec::new()).collect(); for elt in index.into_iter() { let h = hash::hash(&elt.val) as uint; - buckets[h % 256].push(elt); + (&mut buckets[h % 256]).push(elt); } rbml_w.start_tag(tag_index); @@ -1869,7 +1869,7 @@ fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &ast::Crate) { fn visit_struct_field(&mut self, field: &ast::StructField) { self.rbml_w.start_tag(tag_struct_field); self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id); - encode_attributes(self.rbml_w, field.node.attrs[]); + encode_attributes(self.rbml_w, field.node.attrs.index(&FullRange)); self.rbml_w.end_tag(); } } @@ -1941,13 +1941,13 @@ fn encode_misc_info(ecx: &EncodeContext, rbml_w.start_tag(tag_misc_info_crate_items); for item in krate.module.items.iter() { rbml_w.start_tag(tag_mod_child); - rbml_w.wr_str(def_to_string(local_def(item.id))[]); + rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange)); rbml_w.end_tag(); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(def_to_string(local_def( - auxiliary_node_id))[]); + auxiliary_node_id)).index(&FullRange)); rbml_w.end_tag(); true }); @@ -2116,17 +2116,17 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, let mut rbml_w = writer::Encoder::new(wr); - encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name[]); + encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name.index(&FullRange)); encode_crate_triple(&mut rbml_w, tcx.sess .opts .target_triple - []); + .index(&FullRange)); encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash); encode_dylib_dependency_formats(&mut rbml_w, &ecx); let mut i = rbml_w.writer.tell().unwrap(); - encode_attributes(&mut rbml_w, krate.attrs[]); + encode_attributes(&mut rbml_w, krate.attrs.index(&FullRange)); stats.attr_bytes = rbml_w.writer.tell().unwrap() - i; i = rbml_w.writer.tell().unwrap(); diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 7c0645b4ca204..6f75770bcb827 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -315,14 +315,14 @@ impl<'a> Context<'a> { &Some(ref r) => format!("{} which `{}` depends on", message, r.ident) }; - self.sess.span_err(self.span, message[]); + self.sess.span_err(self.span, message.index(&FullRange)); if self.rejected_via_triple.len() > 0 { let mismatches = self.rejected_via_triple.iter(); for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}`, path #{}, triple {}: {}", - self.ident, i+1, got, path.display())[]); + self.ident, i+1, got, path.display()).index(&FullRange)); } } if self.rejected_via_hash.len() > 0 { @@ -332,7 +332,7 @@ impl<'a> Context<'a> { for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path {}{}: {}", - self.ident, "#", i+1, path.display())[]); + self.ident, "#", i+1, path.display()).index(&FullRange)); } match self.root { &None => {} @@ -340,7 +340,7 @@ impl<'a> Context<'a> { for (i, path) in r.paths().iter().enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path #{}: {}", - r.ident, i+1, path.display())[]); + r.ident, i+1, path.display()).index(&FullRange)); } } } @@ -386,7 +386,7 @@ impl<'a> Context<'a> { None => return FileDoesntMatch, Some(file) => file, }; - let (hash, rlib) = if file.starts_with(rlib_prefix[]) && + let (hash, rlib) = if file.starts_with(rlib_prefix.index(&FullRange)) && file.ends_with(".rlib") { (file.slice(rlib_prefix.len(), file.len() - ".rlib".len()), true) @@ -446,26 +446,26 @@ impl<'a> Context<'a> { _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", - self.crate_name)[]); + self.crate_name).index(&FullRange)); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { self.sess.note(format!("path: {}", - p.display())[]); + p.display()).index(&FullRange)); } None => {} } match lib.rlib { Some(ref p) => { self.sess.note(format!("path: {}", - p.display())[]); + p.display()).index(&FullRange)); } None => {} } let data = lib.metadata.as_slice(); let name = decoder::get_crate_name(data); - note_crate_name(self.sess.diagnostic(), name[]); + note_crate_name(self.sess.diagnostic(), name.index(&FullRange)); } None } @@ -519,11 +519,11 @@ impl<'a> Context<'a> { format!("multiple {} candidates for `{}` \ found", flavor, - self.crate_name)[]); + self.crate_name).index(&FullRange)); self.sess.span_note(self.span, format!(r"candidate #1: {}", ret.as_ref().unwrap() - .display())[]); + .display()).index(&FullRange)); error = 1; ret = None; } @@ -531,7 +531,7 @@ impl<'a> Context<'a> { error += 1; self.sess.span_note(self.span, format!(r"candidate #{}: {}", error, - lib.display())[]); + lib.display()).index(&FullRange)); continue } *slot = Some(metadata); @@ -606,17 +606,17 @@ impl<'a> Context<'a> { let mut rlibs = HashSet::new(); let mut dylibs = HashSet::new(); { - let mut locs = locs.iter().map(|l| Path::new(l[])).filter(|loc| { + let mut locs = locs.iter().map(|l| Path::new(l.index(&FullRange))).filter(|loc| { if !loc.exists() { sess.err(format!("extern location for {} does not exist: {}", - self.crate_name, loc.display())[]); + self.crate_name, loc.display()).index(&FullRange)); return false; } let file = match loc.filename_str() { Some(file) => file, None => { sess.err(format!("extern location for {} is not a file: {}", - self.crate_name, loc.display())[]); + self.crate_name, loc.display()).index(&FullRange)); return false; } }; @@ -624,12 +624,12 @@ impl<'a> Context<'a> { return true } else { let (ref prefix, ref suffix) = dylibname; - if file.starts_with(prefix[]) && file.ends_with(suffix[]) { + if file.starts_with(prefix.index(&FullRange)) && file.ends_with(suffix.index(&FullRange)) { return true } } sess.err(format!("extern location for {} is of an unknown type: {}", - self.crate_name, loc.display())[]); + self.crate_name, loc.display()).index(&FullRange)); false }); @@ -662,7 +662,7 @@ impl<'a> Context<'a> { } pub fn note_crate_name(diag: &SpanHandler, name: &str) { - diag.handler().note(format!("crate name: {}", name)[]); + diag.handler().note(format!("crate name: {}", name).index(&FullRange)); } impl ArchiveMetadata { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 07dc13ff0d48f..135cd8d8d081e 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -98,7 +98,7 @@ fn scan(st: &mut PState, mut is_last: F, op: G) -> R where } let end_pos = st.pos; st.pos += 1; - return op(st.data[start_pos..end_pos]); + return op(st.data.index(&(start_pos..end_pos))); } pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident { @@ -251,7 +251,7 @@ fn parse_trait_store_(st: &mut PState, conv: &mut F) -> ty::TraitStore where '&' => ty::RegionTraitStore(parse_region_(st, conv), parse_mutability(st)), c => { st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'", - c)[]) + c).index(&FullRange)) } } } @@ -318,7 +318,7 @@ fn parse_bound_region_(st: &mut PState, conv: &mut F) -> ty::BoundRegion wher } '[' => { let def = parse_def_(st, RegionParameter, conv); - let ident = token::str_to_ident(parse_str(st, ']')[]); + let ident = token::str_to_ident(parse_str(st, ']').index(&FullRange)); ty::BrNamed(def, ident.name) } 'f' => { @@ -357,7 +357,7 @@ fn parse_region_(st: &mut PState, conv: &mut F) -> ty::Region where assert_eq!(next(st), '|'); let index = parse_u32(st); assert_eq!(next(st), '|'); - let nm = token::str_to_ident(parse_str(st, ']')[]); + let nm = token::str_to_ident(parse_str(st, ']').index(&FullRange)); ty::ReEarlyBound(node_id, space, index, nm.name) } 'f' => { @@ -481,7 +481,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w assert_eq!(next(st), '|'); let space = parse_param_space(st); assert_eq!(next(st), '|'); - let name = token::intern(parse_str(st, ']')[]); + let name = token::intern(parse_str(st, ']').index(&FullRange)); return ty::mk_param(tcx, space, index, name); } '~' => return ty::mk_uniq(tcx, parse_ty_(st, conv)), @@ -637,7 +637,7 @@ fn parse_abi_set(st: &mut PState) -> abi::Abi { assert_eq!(next(st), '['); scan(st, |c| c == ']', |bytes| { let abi_str = str::from_utf8(bytes).unwrap(); - abi::lookup(abi_str[]).expect(abi_str) + abi::lookup(abi_str.index(&FullRange)).expect(abi_str) }) } @@ -733,8 +733,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId { panic!(); } - let crate_part = buf[0u..colon_idx]; - let def_part = buf[colon_idx + 1u..len]; + let crate_part = buf.index(&(0u..colon_idx)); + let def_part = buf.index(&((colon_idx + 1u)..len)); let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| s.parse::()) { Some(cn) => cn as ast::CrateNum, diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index b2ad77467276f..955f522b8041b 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -48,7 +48,7 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty) None => { tcx.sess.span_bug(ast_ty.span, format!("unbound path {}", - path.repr(tcx))[]) + path.repr(tcx)).index(&FullRange)) } Some(&d) => d }; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 93a19a01f668f..7f11317a4b96a 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -132,7 +132,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata, // Do an Option dance to use the path after it is moved below. let s = ast_map::path_to_string(ast_map::Values(path.iter())); path_as_str = Some(s); - path_as_str.as_ref().map(|x| x[]) + path_as_str.as_ref().map(|x| x.index(&FullRange)) }); let mut ast_dsr = reader::Decoder::new(ast_doc); let from_id_range = Decodable::decode(&mut ast_dsr).unwrap(); @@ -1900,7 +1900,7 @@ fn decode_side_tables(dcx: &DecodeContext, None => { dcx.tcx.sess.bug( format!("unknown tag found in side tables: {:x}", - tag)[]); + tag).index(&FullRange)); } Some(value) => { let val_doc = entry_doc.get(c::tag_table_val as uint); @@ -1985,7 +1985,7 @@ fn decode_side_tables(dcx: &DecodeContext, _ => { dcx.tcx.sess.bug( format!("unknown tag found in side tables: {:x}", - tag)[]); + tag).index(&FullRange)); } } } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 3c672d0fdb6fa..2f0e3aeee9b52 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -362,7 +362,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let mut cond_exit = discr_exit; for arm in arms.iter() { cond_exit = self.add_dummy_node(&[cond_exit]); // 2 - let pats_exit = self.pats_any(arm.pats[], + let pats_exit = self.pats_any(arm.pats.index(&FullRange), cond_exit); // 3 let guard_exit = self.opt_expr(&arm.guard, pats_exit); // 4 @@ -616,14 +616,14 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.tcx.sess.span_bug( expr.span, format!("no loop scope for id {}", - loop_id)[]); + loop_id).index(&FullRange)); } r => { self.tcx.sess.span_bug( expr.span, format!("bad entry `{}` in def_map for label", - r)[]); + r).index(&FullRange)); } } } diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs index 8a2ecbca20d55..34dae07642d99 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -52,7 +52,7 @@ fn replace_newline_with_backslash_l(s: String) -> String { } impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> { - fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name[]).unwrap() } + fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name.index(&FullRange)).unwrap() } fn node_id(&'a self, &(i,_): &Node<'a>) -> dot::Id<'a> { dot::Id::new(format!("N{}", i.node_id())).unwrap() @@ -85,7 +85,7 @@ 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[])[]); + label.push_str(format!("exiting scope_{} {}", i, s.index(&FullRange)).index(&FullRange)); } dot::LabelText::EscStr(label.into_cow()) } diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index e68a9fb50efd0..5024e5c4f77de 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -74,11 +74,11 @@ impl<'a> CheckLoopVisitor<'a> { Loop => {} Closure => { self.sess.span_err(span, - format!("`{}` inside of a closure", name)[]); + format!("`{}` inside of a closure", name).index(&FullRange)); } Normal => { self.sess.span_err(span, - format!("`{}` outside of loop", name)[]); + format!("`{}` outside of loop", name).index(&FullRange)); } } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index f2b9ecb5ec432..5712ce3792ea6 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -47,7 +47,7 @@ struct Matrix<'a>(Vec>); /// Pretty-printer for matrices of patterns, example: /// ++++++++++++++++++++++++++ -/// + _ + [] + +/// + _ + .index(&FullRange) + /// ++++++++++++++++++++++++++ /// + true + [First] + /// ++++++++++++++++++++++++++ @@ -161,7 +161,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { // First, check legality of move bindings. check_legality_of_move_bindings(cx, arm.guard.is_some(), - arm.pats[]); + arm.pats.index(&FullRange)); // Second, if there is a guard on each arm, make sure it isn't // assigning or borrowing anything mutably. @@ -198,7 +198,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { } // Fourth, check for unreachable arms. - check_arms(cx, inlined_arms[], source); + check_arms(cx, inlined_arms.index(&FullRange), source); // Finally, check if the whole match expression is exhaustive. // Check for empty enum, because is_useful only works on inhabited types. @@ -230,7 +230,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { pat.span, format!("refutable pattern in `for` loop binding: \ `{}` not covered", - pat_to_string(uncovered_pat))[]); + pat_to_string(uncovered_pat)).index(&FullRange)); }); // Check legality of move bindings. @@ -303,7 +303,7 @@ fn check_arms(cx: &MatchCheckCtxt, for pat in pats.iter() { let v = vec![&**pat]; - match is_useful(cx, &seen, v[], LeaveOutWitness) { + match is_useful(cx, &seen, v.index(&FullRange), LeaveOutWitness) { NotUseful => { match source { ast::MatchSource::IfLetDesugar { .. } => { @@ -355,7 +355,7 @@ fn raw_pat<'a>(p: &'a Pat) -> &'a Pat { fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) { match is_useful(cx, matrix, &[DUMMY_WILD_PAT], ConstructWitness) { UsefulWithWitness(pats) => { - let witness = match pats[] { + let witness = match pats.index(&FullRange) { [ref witness] => &**witness, [] => DUMMY_WILD_PAT, _ => unreachable!() @@ -609,7 +609,7 @@ fn is_useful(cx: &MatchCheckCtxt, UsefulWithWitness(pats) => UsefulWithWitness({ let arity = constructor_arity(cx, &c, left_ty); let mut result = { - let pat_slice = pats[]; + let pat_slice = pats.index(&FullRange); let subpats: Vec<_> = range(0, arity).map(|i| { pat_slice.get(i).map_or(DUMMY_WILD_PAT, |p| &**p) }).collect(); @@ -656,10 +656,10 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix, witness: WitnessPreference) -> Usefulness { let arity = constructor_arity(cx, &ctor, lty); let matrix = Matrix(m.iter().filter_map(|r| { - specialize(cx, r[], &ctor, 0u, arity) + specialize(cx, r.index(&FullRange), &ctor, 0u, arity) }).collect()); match specialize(cx, v, &ctor, 0u, arity) { - Some(v) => is_useful(cx, &matrix, v[], witness), + Some(v) => is_useful(cx, &matrix, v.index(&FullRange), witness), None => NotUseful } } @@ -729,7 +729,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat, /// This computes the arity of a constructor. The arity of a constructor /// is how many subpattern patterns of that constructor should be expanded to. /// -/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3. +/// For instance, a tuple pattern (_, 42u, Some(.index(&FullRange))) has the arity of 3. /// A struct pattern's arity is the number of fields it contains, etc. pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint { match ty.sty { @@ -926,8 +926,8 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], } }; head.map(|mut head| { - head.push_all(r[..col]); - head.push_all(r[col + 1..]); + head.push_all(r.index(&(0..col))); + head.push_all(r.index(&((col + 1)..))); head }) } @@ -1044,7 +1044,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, format!("binding pattern {} is not an \ identifier: {}", p.id, - p.node)[]); + p.node).index(&FullRange)); } } } diff --git a/src/librustc/middle/check_static.rs b/src/librustc/middle/check_static.rs index df51cb7e6bc4b..994a2b0dc8abc 100644 --- a/src/librustc/middle/check_static.rs +++ b/src/librustc/middle/check_static.rs @@ -112,7 +112,7 @@ impl<'a, 'tcx> CheckStaticVisitor<'a, 'tcx> { }; self.tcx.sess.span_err(e.span, format!("mutable statics are not allowed \ - to have {}", suffix)[]); + to have {}", suffix).index(&FullRange)); } fn check_static_type(&self, e: &ast::Expr) { @@ -170,7 +170,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> { ty::ty_enum(did, _) if ty::has_dtor(self.tcx, did) => { self.tcx.sess.span_err(e.span, format!("{} are not allowed to have \ - destructors", self.msg())[]) + destructors", self.msg()).index(&FullRange)) } _ => {} } @@ -234,7 +234,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> { let msg = "constants cannot refer to other statics, \ insert an intermediate constant \ instead"; - self.tcx.sess.span_err(e.span, msg[]); + self.tcx.sess.span_err(e.span, msg.index(&FullRange)); } _ => {} } diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index c36b4aa7f231e..75851f0a85333 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -105,7 +105,7 @@ impl<'a, 'ast, 'v> Visitor<'v> for CheckItemRecursionVisitor<'a, 'ast> { _ => { self.sess.span_err(e.span, format!("expected item, found {}", - self.ast_map.node_to_string(def_id.node))[]); + self.ast_map.node_to_string(def_id.node)).index(&FullRange)); return; }, } diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 32482fce4daa8..213b4ac4736b6 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -48,7 +48,7 @@ use std::rc::Rc; // target uses". This _includes_ integer-constants, plus the following // constructors: // -// fixed-size vectors and strings: [] and ""/_ +// fixed-size vectors and strings: .index(&FullRange) and ""/_ // vector and string slices: &[] and &"" // tuples: (,) // enums: foo(...) @@ -117,7 +117,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, None => None, Some(ast_map::NodeItem(it)) => match it.node { ast::ItemEnum(ast::EnumDef { ref variants }, _) => { - variant_expr(variants[], variant_def.node) + variant_expr(variants.index(&FullRange), variant_def.node) } _ => None }, @@ -138,7 +138,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, // NOTE this doesn't do the right thing, it compares inlined // NodeId's to the original variant_def's NodeId, but they // come from different crates, so they will likely never match. - variant_expr(variants[], variant_def.node).map(|e| e.id) + variant_expr(variants.index(&FullRange), variant_def.node).map(|e| e.id) } _ => None }, @@ -364,7 +364,7 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P { pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val { match eval_const_expr_partial(tcx, e) { Ok(r) => r, - Err(s) => tcx.sess.span_fatal(e.span, s[]) + Err(s) => tcx.sess.span_fatal(e.span, s.index(&FullRange)) } } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index e78b8047f6958..49ae1bce193a0 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -312,7 +312,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let mut t = on_entry.to_vec(); self.apply_gen_kill(cfgidx, t.as_mut_slice()); temp_bits = t; - temp_bits[] + temp_bits.index(&FullRange) } }; debug!("{} each_bit_for_node({}, cfgidx={}) bits={}", @@ -421,7 +421,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let bits = self.kills.slice_mut(start, end); debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [before]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); - bits.clone_from_slice(orig_kills[]); + bits.clone_from_slice(orig_kills.index(&FullRange)); debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [after]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); } @@ -554,7 +554,7 @@ fn bits_to_string(words: &[uint]) -> String { let mut v = word; for _ in range(0u, uint::BYTES) { result.push(sep); - result.push_str(format!("{:02x}", v & 0xFF)[]); + result.push_str(format!("{:02x}", v & 0xFF).index(&FullRange)); v >>= 8; sep = '-'; } diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 6b56ece28bdb2..8182dec2db064 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -118,7 +118,7 @@ fn calculate_type(sess: &session::Session, let src = sess.cstore.get_used_crate_source(cnum).unwrap(); if src.rlib.is_some() { return } sess.err(format!("dependency `{}` not found in rlib format", - data.name)[]); + data.name).index(&FullRange)); }); return Vec::new(); } @@ -197,7 +197,7 @@ fn calculate_type(sess: &session::Session, match kind { cstore::RequireStatic => "rlib", cstore::RequireDynamic => "dylib", - })[]); + }).index(&FullRange)); } } } @@ -222,7 +222,7 @@ fn add_library(sess: &session::Session, let data = sess.cstore.get_crate_data(cnum); sess.err(format!("cannot satisfy dependencies so `{}` only \ shows up once", - data.name)[]); + data.name).index(&FullRange)); sess.help("having upstream crates all available in one format \ will likely make this go away"); } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index df2a4e4c2532a..ca20cbc736dc0 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -869,7 +869,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => self.tcx().sess.span_bug(expr.span, format!("bad overloaded deref type {}", - method_ty.repr(self.tcx()))[]) + method_ty.repr(self.tcx())).index(&FullRange)) }; let bk = ty::BorrowKind::from_mutbl(m); self.delegate.borrow(expr.id, expr.span, cmt, @@ -1191,7 +1191,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let msg = format!("Pattern has unexpected def: {} and type {}", def, cmt_pat.ty.repr(tcx)); - tcx.sess.span_bug(pat.span, msg[]) + tcx.sess.span_bug(pat.span, msg.index(&FullRange)) } } } diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index dd711fcbf022e..9122359bb9ef3 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -142,7 +142,7 @@ pub trait Combine<'tcx> : Sized { for _ in a_regions.iter() { invariance.push(ty::Invariant); } - invariance[] + invariance.index(&FullRange) } }; @@ -480,7 +480,7 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, format!("{}: bot and var types should have been handled ({},{})", this.tag(), a.repr(this.infcx().tcx), - b.repr(this.infcx().tcx))[]); + b.repr(this.infcx().tcx)).index(&FullRange)); } (&ty::ty_err, _) | (_, &ty::ty_err) => { @@ -856,7 +856,7 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> { self.tcx().sess.span_bug( self.span, format!("Encountered early bound region when generalizing: {}", - r.repr(self.tcx()))[]); + r.repr(self.tcx())).index(&FullRange)); } // Always make a fresh region variable for skolemized regions; diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index e58ff53b00cb9..1566a7938d3dd 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -200,9 +200,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ref trace_origins, ref same_regions) => { if !same_regions.is_empty() { - self.report_processed_errors(var_origins[], - trace_origins[], - same_regions[]); + self.report_processed_errors(var_origins.index(&FullRange), + trace_origins.index(&FullRange), + same_regions.index(&FullRange)); } } } @@ -376,7 +376,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { format!("{}: {} ({})", message_root_str, expected_found_str, - ty::type_err_to_str(self.tcx, terr))[]); + ty::type_err_to_str(self.tcx, terr)).index(&FullRange)); match trace.origin { infer::MatchExpressionArm(_, arm_span) => @@ -445,25 +445,25 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { // Does the required lifetime have a nice name we can print? self.tcx.sess.span_err( origin.span(), - format!("{} may not live long enough", labeled_user_string)[]); + format!("{} may not live long enough", labeled_user_string).index(&FullRange)); self.tcx.sess.span_help( origin.span(), format!( "consider adding an explicit lifetime bound `{}: {}`...", bound_kind.user_string(self.tcx), - sub.user_string(self.tcx))[]); + sub.user_string(self.tcx)).index(&FullRange)); } ty::ReStatic => { // Does the required lifetime have a nice name we can print? self.tcx.sess.span_err( origin.span(), - format!("{} may not live long enough", labeled_user_string)[]); + format!("{} may not live long enough", labeled_user_string).index(&FullRange)); self.tcx.sess.span_help( origin.span(), format!( "consider adding an explicit lifetime bound `{}: 'static`...", - bound_kind.user_string(self.tcx))[]); + bound_kind.user_string(self.tcx)).index(&FullRange)); } _ => { @@ -472,15 +472,15 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { origin.span(), format!( "{} may not live long enough", - labeled_user_string)[]); + labeled_user_string).index(&FullRange)); self.tcx.sess.span_help( origin.span(), format!( "consider adding an explicit lifetime bound for `{}`", - bound_kind.user_string(self.tcx))[]); + bound_kind.user_string(self.tcx)).index(&FullRange)); note_and_explain_region( self.tcx, - format!("{} must be valid for ", labeled_user_string)[], + format!("{} must be valid for ", labeled_user_string).index(&FullRange), sub, "..."); } @@ -522,7 +522,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string())[]); + .to_string()).index(&FullRange)); note_and_explain_region( self.tcx, "...the borrowed pointer is valid for ", @@ -534,7 +534,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string())[], + .to_string()).index(&FullRange), sup, ""); } @@ -580,7 +580,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { outlive the enclosing closure", ty::local_var_name_str(self.tcx, id).get() - .to_string())[]); + .to_string()).index(&FullRange)); note_and_explain_region( self.tcx, "captured variable is valid for ", @@ -622,7 +622,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, format!("the type `{}` does not fulfill the \ required lifetime", - self.ty_to_string(ty))[]); + self.ty_to_string(ty)).index(&FullRange)); note_and_explain_region(self.tcx, "type must outlive ", sub, @@ -648,7 +648,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, format!("the type `{}` (provided as the value of \ a type parameter) is not valid at this point", - self.ty_to_string(ty))[]); + self.ty_to_string(ty)).index(&FullRange)); note_and_explain_region(self.tcx, "type must outlive ", sub, @@ -714,7 +714,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, format!("type of expression contains references \ that are not valid during the expression: `{}`", - self.ty_to_string(t))[]); + self.ty_to_string(t)).index(&FullRange)); note_and_explain_region( self.tcx, "type is only valid for ", @@ -736,7 +736,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, format!("in type `{}`, reference has a longer lifetime \ than the data it references", - self.ty_to_string(ty))[]); + self.ty_to_string(ty)).index(&FullRange)); note_and_explain_region( self.tcx, "the pointer is valid for ", @@ -861,7 +861,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { let (fn_decl, generics, unsafety, ident, expl_self, span) = node_inner.expect("expect item fn"); let taken = lifetimes_in_scope(self.tcx, scope_id); - let life_giver = LifeGiver::with_taken(taken[]); + let life_giver = LifeGiver::with_taken(taken.index(&FullRange)); let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self, generics, same_regions, &life_giver); let (fn_decl, expl_self, generics) = rebuilder.rebuild(); @@ -937,7 +937,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { } expl_self_opt = self.rebuild_expl_self(expl_self_opt, lifetime, &anon_nums, ®ion_names); - inputs = self.rebuild_args_ty(inputs[], lifetime, + inputs = self.rebuild_args_ty(inputs.index(&FullRange), lifetime, &anon_nums, ®ion_names); output = self.rebuild_output(&output, lifetime, &anon_nums, ®ion_names); ty_params = self.rebuild_ty_params(ty_params, lifetime, @@ -972,7 +972,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { names.push(lt_name); } names.sort(); - let name = token::str_to_ident(names[0][]).name; + let name = token::str_to_ident(names[0].index(&FullRange)).name; return (name_to_dummy_lifetime(name), Kept); } return (self.life_giver.give_lifetime(), Fresh); @@ -1222,7 +1222,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { .sess .fatal(format!( "unbound path {}", - pprust::path_to_string(path))[]) + pprust::path_to_string(path)).index(&FullRange)) } Some(&d) => d }; @@ -1420,7 +1420,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { opt_explicit_self, generics); let msg = format!("consider using an explicit lifetime \ parameter as shown: {}", suggested_fn); - self.tcx.sess.span_help(span, msg[]); + self.tcx.sess.span_help(span, msg.index(&FullRange)); } fn report_inference_failure(&self, @@ -1463,7 +1463,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { var_origin.span(), format!("cannot infer an appropriate lifetime{} \ due to conflicting requirements", - var_description)[]); + var_description).index(&FullRange)); } fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) { @@ -1511,7 +1511,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_note( trace.origin.span(), format!("...so that {} ({})", - desc, values_str)[]); + desc, values_str).index(&FullRange)); } None => { // Really should avoid printing this error at @@ -1520,7 +1520,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { // doing right now. - nmatsakis self.tcx.sess.span_note( trace.origin.span(), - format!("...so that {}", desc)[]); + format!("...so that {}", desc).index(&FullRange)); } } } @@ -1537,7 +1537,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { "...so that closure can access `{}`", ty::local_var_name_str(self.tcx, upvar_id.var_id) .get() - .to_string())[]) + .to_string()).index(&FullRange)) } infer::InfStackClosure(span) => { self.tcx.sess.span_note( @@ -1562,7 +1562,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { does not outlive the enclosing closure", ty::local_var_name_str( self.tcx, - id).get().to_string())[]); + id).get().to_string()).index(&FullRange)); } infer::IndexSlice(span) => { self.tcx.sess.span_note( @@ -1606,7 +1606,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { span, format!("...so type `{}` of expression is valid during the \ expression", - self.ty_to_string(t))[]); + self.ty_to_string(t)).index(&FullRange)); } infer::BindingTypeIsNotValidAtDecl(span) => { self.tcx.sess.span_note( @@ -1618,14 +1618,14 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { span, format!("...so that the reference type `{}` \ does not outlive the data it points at", - self.ty_to_string(ty))[]); + self.ty_to_string(ty)).index(&FullRange)); } infer::RelateParamBound(span, t) => { self.tcx.sess.span_note( span, format!("...so that the type `{}` \ will meet the declared lifetime bounds", - self.ty_to_string(t))[]); + self.ty_to_string(t)).index(&FullRange)); } infer::RelateDefaultParamBound(span, t) => { self.tcx.sess.span_note( @@ -1633,13 +1633,13 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { format!("...so that type parameter \ instantiated with `{}`, \ will meet its declared lifetime bounds", - self.ty_to_string(t))[]); + self.ty_to_string(t)).index(&FullRange)); } infer::RelateRegionParamBound(span) => { self.tcx.sess.span_note( span, format!("...so that the declared lifetime parameter bounds \ - are satisfied")[]); + are satisfied").index(&FullRange)); } } } @@ -1691,7 +1691,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt, Some(node) => match node { ast_map::NodeItem(item) => match item.node { ast::ItemFn(_, _, _, ref gen, _) => { - taken.push_all(gen.lifetimes[]); + taken.push_all(gen.lifetimes.index(&FullRange)); None }, _ => None @@ -1699,7 +1699,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt, ast_map::NodeImplItem(ii) => { match *ii { ast::MethodImplItem(ref m) => { - taken.push_all(m.pe_generics().lifetimes[]); + taken.push_all(m.pe_generics().lifetimes.index(&FullRange)); Some(m.id) } ast::TypeImplItem(_) => None, @@ -1758,10 +1758,10 @@ impl LifeGiver { let mut lifetime; loop { let mut s = String::from_str("'"); - s.push_str(num_to_string(self.counter.get())[]); + s.push_str(num_to_string(self.counter.get()).index(&FullRange)); if !self.taken.contains(&s) { lifetime = name_to_dummy_lifetime( - token::str_to_ident(s[]).name); + token::str_to_ident(s.index(&FullRange)).name); self.generated.borrow_mut().push(lifetime); break; } diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index bf0a9cfbea66d..cd4705d4fb2db 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -189,7 +189,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C span, format!("region {} is not associated with \ any bound region from A!", - r0)[]) + r0).index(&FullRange)) } } @@ -322,7 +322,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C } infcx.tcx.sess.span_bug( span, - format!("could not find original bound region for {}", r)[]); + format!("could not find original bound region for {}", r).index(&FullRange)); } fn fresh_bound_variable(infcx: &InferCtxt, debruijn: ty::DebruijnIndex) -> ty::Region { @@ -339,7 +339,7 @@ fn var_ids<'tcx, T: Combine<'tcx>>(combiner: &T, r => { combiner.infcx().tcx.sess.span_bug( combiner.trace().origin.span(), - format!("found non-region-vid: {}", r)[]); + format!("found non-region-vid: {}", r).index(&FullRange)); } }).collect() } diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index c2db81d311483..a3d94e8b844b5 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -1002,7 +1002,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { self.tcx.sess.span_err(sp, format!("{}{}", mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty), - error_str)[]); + error_str).index(&FullRange)); for err in err.iter() { ty::note_and_explain_type_err(self.tcx, *err) diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index d30a6ff1cd9d5..ea5d8456117ba 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -475,7 +475,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { origin.span(), format!("cannot relate bound region: {} <= {}", sub.repr(self.tcx), - sup.repr(self.tcx))[]); + sup.repr(self.tcx)).index(&FullRange)); } (_, ReStatic) => { // all regions are subregions of static, so we can ignore this @@ -736,7 +736,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.bug( format!("cannot relate bound region: LUB({}, {})", a.repr(self.tcx), - b.repr(self.tcx))[]); + b.repr(self.tcx)).index(&FullRange)); } (ReStatic, _) | (_, ReStatic) => { @@ -753,7 +753,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { format!("lub_concrete_regions invoked with \ non-concrete regions: {}, {}", a, - b)[]); + b).index(&FullRange)); } (ReFree(ref fr), ReScope(s_id)) | @@ -836,7 +836,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.bug( format!("cannot relate bound region: GLB({}, {})", a.repr(self.tcx), - b.repr(self.tcx))[]); + b.repr(self.tcx)).index(&FullRange)); } (ReStatic, r) | (r, ReStatic) => { @@ -856,7 +856,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { format!("glb_concrete_regions invoked with \ non-concrete regions: {}, {}", a, - b)[]); + b).index(&FullRange)); } (ReFree(ref fr), ReScope(s_id)) | @@ -977,7 +977,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.expansion(var_data.as_mut_slice()); self.contraction(var_data.as_mut_slice()); let values = - self.extract_values_and_collect_conflicts(var_data[], + self.extract_values_and_collect_conflicts(var_data.index(&FullRange), errors); self.collect_concrete_region_errors(&values, errors); values @@ -1415,7 +1415,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { for var {}, lower_bounds={}, upper_bounds={}", node_idx, lower_bounds.repr(self.tcx), - upper_bounds.repr(self.tcx))[]); + upper_bounds.repr(self.tcx)).index(&FullRange)); } fn collect_error_for_contracting_node( @@ -1459,7 +1459,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { format!("collect_error_for_contracting_node() could not find error \ for var {}, upper_bounds={}", node_idx, - upper_bounds.repr(self.tcx))[]); + upper_bounds.repr(self.tcx)).index(&FullRange)); } fn collect_concrete_regions(&self, diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs index 3ed866d4aba8f..9035d72e9a2fb 100644 --- a/src/librustc/middle/infer/resolve.rs +++ b/src/librustc/middle/infer/resolve.rs @@ -96,7 +96,7 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> { ty::ty_infer(_) => { self.infcx.tcx.sess.bug( format!("Unexpected type in full type resolver: {}", - t.repr(self.infcx.tcx))[]); + t.repr(self.infcx.tcx)).index(&FullRange)); } _ => { ty_fold::super_fold_ty(self, t) diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 77875139be3a3..24cfe51123058 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -326,7 +326,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { self.tcx .sess .span_bug(span, format!("no variable registered for id {}", - node_id)[]); + node_id).index(&FullRange)); } } } @@ -597,7 +597,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { self.ir.tcx.sess.span_bug( span, format!("no live node registered for node {}", - node_id)[]); + node_id).index(&FullRange)); } } } @@ -1132,7 +1132,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { // Uninteresting cases: just propagate in rev exec order ast::ExprVec(ref exprs) => { - self.propagate_through_exprs(exprs[], succ) + self.propagate_through_exprs(exprs.index(&FullRange), succ) } ast::ExprRepeat(ref element, ref count) => { @@ -1157,7 +1157,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } else { succ }; - let succ = self.propagate_through_exprs(args[], succ); + let succ = self.propagate_through_exprs(args.index(&FullRange), succ); self.propagate_through_expr(&**f, succ) } @@ -1170,11 +1170,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } else { succ }; - self.propagate_through_exprs(args[], succ) + self.propagate_through_exprs(args.index(&FullRange), succ) } ast::ExprTup(ref exprs) => { - self.propagate_through_exprs(exprs[], succ) + self.propagate_through_exprs(exprs.index(&FullRange), succ) } ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => { diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2b8c9b532e593..af80edb739eb5 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -594,7 +594,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { span, format!("Upvar of non-closure {} - {}", fn_node_id, - ty.repr(self.tcx()))[]); + ty.repr(self.tcx())).index(&FullRange)); } } } @@ -1505,7 +1505,7 @@ impl<'tcx> Repr<'tcx> for InteriorKind { token::get_name(fld).get().to_string() } InteriorField(PositionalField(i)) => format!("#{}", i), - InteriorElement(_) => "[]".to_string(), + InteriorElement(_) => ".index(&FullRange)".to_string(), } } } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 50e328ef0e3c3..df545c7570a02 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -615,10 +615,10 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { match result { None => true, Some((span, msg, note)) => { - self.tcx.sess.span_err(span, msg[]); + self.tcx.sess.span_err(span, msg.index(&FullRange)); match note { Some((span, msg)) => { - self.tcx.sess.span_note(span, msg[]) + self.tcx.sess.span_note(span, msg.index(&FullRange)) } None => {}, } @@ -720,7 +720,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { UnnamedField(idx) => format!("field #{} of {} is private", idx + 1, struct_desc), }; - self.tcx.sess.span_err(span, msg[]); + self.tcx.sess.span_err(span, msg.index(&FullRange)); } // Given the ID of a method, checks to ensure it's in scope. @@ -742,7 +742,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { method_id, None, format!("method `{}`", - string)[])); + string).index(&FullRange))); } // Checks that a path is in scope. @@ -756,7 +756,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.ensure_public(span, def, Some(origdid), - format!("{} `{}`", tyname, name)[]) + format!("{} `{}`", tyname, name).index(&FullRange)) }; match self.last_private_map[path_id] { diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 5736e3072862a..51602e88f9342 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -50,7 +50,7 @@ fn generics_require_inlining(generics: &ast::Generics) -> bool { // monomorphized or it was marked with `#[inline]`. This will only return // true for functions. fn item_might_be_inlined(item: &ast::Item) -> bool { - if attributes_specify_inlining(item.attrs[]) { + if attributes_specify_inlining(item.attrs.index(&FullRange)) { return true } @@ -65,7 +65,7 @@ fn item_might_be_inlined(item: &ast::Item) -> bool { fn method_might_be_inlined(tcx: &ty::ctxt, method: &ast::Method, impl_src: ast::DefId) -> bool { - if attributes_specify_inlining(method.attrs[]) || + if attributes_specify_inlining(method.attrs.index(&FullRange)) || generics_require_inlining(method.pe_generics()) { return true } @@ -202,7 +202,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { ast::MethodImplItem(ref method) => { if generics_require_inlining(method.pe_generics()) || attributes_specify_inlining( - method.attrs[]) { + method.attrs.index(&FullRange)) { true } else { let impl_did = self.tcx @@ -249,7 +249,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { None => { self.tcx.sess.bug(format!("found unmapped ID in worklist: \ {}", - search_item)[]) + search_item).index(&FullRange)) } } } @@ -341,7 +341,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { .bug(format!("found unexpected thingy in worklist: {}", self.tcx .map - .node_to_string(search_item))[]) + .node_to_string(search_item)).index(&FullRange)) } } } diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 68e257bc0c5ec..5be092eb1bd3e 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -643,7 +643,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) { // A, but the inner rvalues `a()` and `b()` have an extended lifetime // due to rule C. // - // FIXME(#6308) -- Note that `[]` patterns work more smoothly post-DST. + // FIXME(#6308) -- Note that `.index(&FullRange)` patterns work more smoothly post-DST. match local.init { Some(ref expr) => { diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 68cb8ca39b492..6cdbd9872bc4e 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -399,7 +399,7 @@ impl<'a> LifetimeContext<'a> { self.sess.span_err( lifetime_ref.span, format!("use of undeclared lifetime name `{}`", - token::get_name(lifetime_ref.name))[]); + token::get_name(lifetime_ref.name)).index(&FullRange)); } fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec) { @@ -413,7 +413,7 @@ impl<'a> LifetimeContext<'a> { lifetime.lifetime.span, format!("illegal lifetime parameter name: `{}`", token::get_name(lifetime.lifetime.name)) - []); + .index(&FullRange)); } } @@ -427,7 +427,7 @@ impl<'a> LifetimeContext<'a> { format!("lifetime name `{}` declared twice in \ the same scope", token::get_name(lifetime_j.lifetime.name)) - []); + .index(&FullRange)); } } diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index cd29ce28ac174..a3973d5854263 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -604,7 +604,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> { (space={}, index={})", region_name.as_str(), self.root_ty.repr(self.tcx()), - space, i)[]); + space, i).index(&FullRange)); } } } @@ -661,7 +661,7 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> { p.space, p.idx, self.root_ty.repr(self.tcx()), - self.substs.repr(self.tcx()))[]); + self.substs.repr(self.tcx())).index(&FullRange)); } }; diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 42b6e54420b40..49c7d6aafaa5e 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -137,7 +137,7 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::ty_err => { tcx.sess.bug( format!("ty_is_local invoked on unexpected type: {}", - ty.repr(tcx))[]) + ty.repr(tcx)).index(&FullRange)) } } } diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 59322fcc632e8..fd6773afb765d 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -339,5 +339,5 @@ pub fn suggest_new_overflow_limit(tcx: &ty::ctxt, span: Span) { span, format!( "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate", - suggested_limit)[]); + suggested_limit).index(&FullRange)); } diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index c2327adece8e0..c5800f3b48caa 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -227,7 +227,7 @@ impl<'tcx> FulfillmentContext<'tcx> { } pub fn pending_obligations(&self) -> &[PredicateObligation<'tcx>] { - self.predicates[] + self.predicates.index(&FullRange) } /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 2393b7d733d00..4ffae39ea44f0 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -903,7 +903,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let all_bounds = util::transitive_bounds( - self.tcx(), caller_trait_refs[]); + self.tcx(), caller_trait_refs.index(&FullRange)); let matching_bounds = all_bounds.filter( @@ -1467,7 +1467,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug( format!( "asked to assemble builtin bounds of unexpected type: {}", - self_ty.repr(self.tcx()))[]); + self_ty.repr(self.tcx())).index(&FullRange)); } }; @@ -1637,7 +1637,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.span_bug( obligation.cause.span, format!("builtin bound for {} was ambig", - obligation.repr(self.tcx()))[]); + obligation.repr(self.tcx())).index(&FullRange)); } } } @@ -1816,7 +1816,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.span_bug( obligation.cause.span, format!("Fn pointer candidate for inappropriate self type: {}", - self_ty.repr(self.tcx()))[]); + self_ty.repr(self.tcx())).index(&FullRange)); } }; @@ -1946,7 +1946,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug( format!("Impl {} was matchable against {} but now is not", impl_def_id.repr(self.tcx()), - obligation.repr(self.tcx()))[]); + obligation.repr(self.tcx())).index(&FullRange)); } } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c359233eca173..af35b9e0e8273 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2006,8 +2006,8 @@ impl<'tcx> Predicate<'tcx> { /// struct Foo> { ... } /// /// Here, the `Generics` for `Foo` would contain a list of bounds like -/// `[[], [U:Bar]]`. Now if there were some particular reference -/// like `Foo`, then the `GenericBounds` would be `[[], +/// `[.index(&FullRange), [U:Bar]]`. Now if there were some particular reference +/// like `Foo`, then the `GenericBounds` would be `[.index(&FullRange), /// [uint:Bar]]`. #[derive(Clone, Show)] pub struct GenericBounds<'tcx> { @@ -2184,7 +2184,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { _ => { cx.sess.bug(format!("ParameterEnvironment::from_item(): \ `{}` is not an item", - cx.map.node_to_string(id))[]) + cx.map.node_to_string(id)).index(&FullRange)) } } } @@ -2269,7 +2269,7 @@ impl UnboxedClosureKind { }; match result { Ok(trait_did) => trait_did, - Err(err) => cx.sess.fatal(err[]), + Err(err) => cx.sess.fatal(err.index(&FullRange)), } } } @@ -2590,7 +2590,7 @@ impl FlagComputation { } &ty_tup(ref ts) => { - self.add_tys(ts[]); + self.add_tys(ts.index(&FullRange)); } &ty_bare_fn(_, ref f) => { @@ -2613,7 +2613,7 @@ impl FlagComputation { fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) { let mut computation = FlagComputation::new(); - computation.add_tys(fn_sig.0.inputs[]); + computation.add_tys(fn_sig.0.inputs.index(&FullRange)); if let ty::FnConverging(output) = fn_sig.0.output { computation.add_ty(output); @@ -2782,7 +2782,7 @@ pub fn mk_trait<'tcx>(cx: &ctxt<'tcx>, fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool { bounds.len() == 0 || - bounds[1..].iter().enumerate().all( + bounds.index(&(1..)).iter().enumerate().all( |(index, bound)| bounds[index].sort_key() <= bound.sort_key()) } @@ -3037,7 +3037,7 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { ty_str => mk_mach_uint(cx, ast::TyU8), ty_open(ty) => sequence_element_type(cx, ty), _ => cx.sess.bug(format!("sequence_element_type called on non-sequence value: {}", - ty_to_string(cx, ty))[]), + ty_to_string(cx, ty)).index(&FullRange)), } } @@ -3371,7 +3371,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { ty_struct(did, substs) => { let flds = struct_fields(cx, did, substs); let mut res = - TypeContents::union(flds[], + TypeContents::union(flds.index(&FullRange), |f| tc_mt(cx, f.mt, cache)); if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) { @@ -3395,15 +3395,15 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { } ty_tup(ref tys) => { - TypeContents::union(tys[], + TypeContents::union(tys.index(&FullRange), |ty| tc_ty(cx, *ty, cache)) } ty_enum(did, substs) => { let variants = substd_enum_variants(cx, did, substs); let mut res = - TypeContents::union(variants[], |variant| { - TypeContents::union(variant.args[], + TypeContents::union(variants.index(&FullRange), |variant| { + TypeContents::union(variant.args.index(&FullRange), |arg_ty| { tc_ty(cx, *arg_ty, cache) }) @@ -3986,7 +3986,7 @@ pub fn close_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_open(ty) => mk_rptr(cx, cx.mk_region(ReStatic), mt {ty: ty, mutbl:ast::MutImmutable}), _ => cx.sess.bug(format!("Trying to close a non-open type {}", - ty_to_string(cx, ty))[]) + ty_to_string(cx, ty)).index(&FullRange)) } } @@ -4087,7 +4087,7 @@ pub fn node_id_to_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) Some(ty) => ty.clone(), None => cx.sess.bug( format!("node_id_to_trait_ref: no trait ref for node `{}`", - cx.map.node_to_string(id))[]) + cx.map.node_to_string(id)).index(&FullRange)) } } @@ -4100,7 +4100,7 @@ pub fn node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Ty<'tcx> { Some(ty) => ty, None => cx.sess.bug( format!("node_id_to_type: no type for node `{}`", - cx.map.node_to_string(id))[]) + cx.map.node_to_string(id)).index(&FullRange)) } } @@ -4187,7 +4187,7 @@ pub fn ty_region(tcx: &ctxt, tcx.sess.span_bug( span, format!("ty_region() invoked on an inappropriate ty: {}", - s)[]); + s).index(&FullRange)); } } } @@ -4248,11 +4248,11 @@ pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { Some(f) => { cx.sess.bug(format!("Node id {} is not an expr: {}", id, - f)[]); + f).index(&FullRange)); } None => { cx.sess.bug(format!("Node id {} is not present \ - in the node map", id)[]); + in the node map", id).index(&FullRange)); } } } @@ -4268,14 +4268,14 @@ pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { cx.sess.bug( format!("Variable id {} maps to {}, not local", id, - pat)[]); + pat).index(&FullRange)); } } } r => { cx.sess.bug(format!("Variable id {} maps to {}, not local", id, - r)[]); + r).index(&FullRange)); } } } @@ -4306,7 +4306,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, cx.sess.bug( format!("AdjustReifyFnPointer adjustment on non-fn-item: \ {}", - b)[]); + b).index(&FullRange)); } } } @@ -4334,7 +4334,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, {}", i, ty_to_string(cx, adjusted_ty)) - []); + .index(&FullRange)); } } } @@ -4397,7 +4397,7 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, } _ => cx.sess.span_bug(span, format!("UnsizeLength with bad sty: {}", - ty_to_string(cx, ty))[]) + ty_to_string(cx, ty)).index(&FullRange)) }, &UnsizeStruct(box ref k, tp_index) => match ty.sty { ty_struct(did, substs) => { @@ -4409,7 +4409,7 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, } _ => cx.sess.span_bug(span, format!("UnsizeStruct with bad sty: {}", - ty_to_string(cx, ty))[]) + ty_to_string(cx, ty)).index(&FullRange)) }, &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { mk_trait(cx, principal.clone(), bounds.clone()) @@ -4422,7 +4422,7 @@ pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def { Some(&def) => def, None => { tcx.sess.span_bug(expr.span, format!( - "no def-map entry for expr {}", expr.id)[]); + "no def-map entry for expr {}", expr.id).index(&FullRange)); } } } @@ -4517,7 +4517,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { expr.span, format!("uncategorized def for expr {}: {}", expr.id, - def)[]); + def).index(&FullRange)); } } } @@ -4642,7 +4642,7 @@ pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) token::get_name(name), fields.iter() .map(|f| token::get_name(f.name).get().to_string()) - .collect::>())[]); + .collect::>()).index(&FullRange)); } pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem]) @@ -4897,7 +4897,7 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) match item.node { ItemTrait(_, _, _, ref ms) => { let (_, p) = - ast_util::split_trait_methods(ms[]); + ast_util::split_trait_methods(ms.index(&FullRange)); p.iter() .map(|m| { match impl_or_trait_item( @@ -4916,14 +4916,14 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) _ => { cx.sess.bug(format!("provided_trait_methods: `{}` is \ not a trait", - id)[]) + id).index(&FullRange)) } } } _ => { cx.sess.bug(format!("provided_trait_methods: `{}` is not a \ trait", - id)[]) + id).index(&FullRange)) } } } else { @@ -5160,7 +5160,7 @@ impl<'tcx> VariantInfo<'tcx> { }, ast::StructVariantKind(ref struct_def) => { - let fields: &[StructField] = struct_def.fields[]; + let fields: &[StructField] = struct_def.fields.index(&FullRange); assert!(fields.len() > 0); @@ -5311,7 +5311,7 @@ pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) cx.sess .span_err(e.span, format!("expected constant: {}", - *err)[]); + *err).index(&FullRange)); } }, None => {} @@ -5601,7 +5601,7 @@ pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec { _ => { cx.sess.bug( format!("ID not mapped to struct fields: {}", - cx.map.node_to_string(did.node))[]); + cx.map.node_to_string(did.node)).index(&FullRange)); } } } else { @@ -5634,7 +5634,7 @@ pub fn struct_fields<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &Substs<'tc pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec> { v.iter().enumerate().map(|(i, &f)| { field { - name: token::intern(i.to_string()[]), + name: token::intern(i.to_string().index(&FullRange)), mt: mt { ty: f, mutbl: MutImmutable @@ -5845,7 +5845,7 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { }; tcx.sess.span_err(count_expr.span, format!( "expected positive integer for repeat count, found {}", - found)[]); + found).index(&FullRange)); } Err(_) => { let found = match count_expr.node { @@ -5860,7 +5860,7 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { }; tcx.sess.span_err(count_expr.span, format!( "expected constant integer for repeat count, found {}", - found)[]); + found).index(&FullRange)); } } 0 @@ -6644,7 +6644,7 @@ pub fn with_freevars(tcx: &ty::ctxt, fid: ast::NodeId, f: F) -> T where { match tcx.freevars.borrow().get(&fid) { None => f(&[]), - Some(d) => f(d[]) + Some(d) => f(d.index(&FullRange)) } } diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index 44a223954858a..a38298d52dd87 100644 --- a/src/librustc/plugin/load.rs +++ b/src/librustc/plugin/load.rs @@ -223,17 +223,17 @@ impl<'a> PluginLoader<'a> { // this is fatal: there are almost certainly macros we need // inside this crate, so continue would spew "macro undefined" // errors - Err(err) => self.sess.span_fatal(vi.span, err[]) + Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange)) }; unsafe { let registrar = - match lib.symbol(symbol[]) { + match lib.symbol(symbol.index(&FullRange)) { Ok(registrar) => { mem::transmute::<*mut u8,PluginRegistrarFun>(registrar) } // again fatal if we can't register macros - Err(err) => self.sess.span_fatal(vi.span, err[]) + Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange)) }; // Intentionally leak the dynamic library. We can't ever unload it diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 138f648049c73..88a71e53b6034 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -559,17 +559,17 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions match (value, opt_type_desc) { (Some(..), None) => { early_error(format!("codegen option `{}` takes no \ - value", key)[]) + value", key).index(&FullRange)) } (None, Some(type_desc)) => { early_error(format!("codegen option `{0}` requires \ {1} (-C {0}=)", - key, type_desc)[]) + key, type_desc).index(&FullRange)) } (Some(value), Some(type_desc)) => { early_error(format!("incorrect value `{}` for codegen \ option `{}` - {} was expected", - value, key, type_desc)[]) + value, key, type_desc).index(&FullRange)) } (None, None) => unreachable!() } @@ -579,7 +579,7 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions } if !found { early_error(format!("unknown codegen option: `{}`", - key)[]); + key).index(&FullRange)); } } return cg; @@ -592,10 +592,10 @@ pub fn default_lib_output() -> CrateType { pub fn default_configuration(sess: &Session) -> ast::CrateConfig { use syntax::parse::token::intern_and_get_ident as intern; - let end = sess.target.target.target_endian[]; - let arch = sess.target.target.arch[]; - let wordsz = sess.target.target.target_word_size[]; - let os = sess.target.target.target_os[]; + let end = sess.target.target.target_endian.index(&FullRange); + let arch = sess.target.target.arch.index(&FullRange); + let wordsz = sess.target.target.target_word_size.index(&FullRange); + let os = sess.target.target.target_os.index(&FullRange); let fam = match sess.target.target.options.is_like_windows { true => InternedString::new("windows"), @@ -631,23 +631,23 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig { append_configuration(&mut user_cfg, InternedString::new("test")) } let mut v = user_cfg.into_iter().collect::>(); - v.push_all(default_cfg[]); + v.push_all(default_cfg.index(&FullRange)); v } pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config { - let target = match Target::search(opts.target_triple[]) { + let target = match Target::search(opts.target_triple.index(&FullRange)) { Ok(t) => t, Err(e) => { - sp.handler().fatal((format!("Error loading target specification: {}", e))[]); + sp.handler().fatal((format!("Error loading target specification: {}", e)).index(&FullRange)); } }; - let (int_type, uint_type) = match target.target_word_size[] { + let (int_type, uint_type) = match target.target_word_size.index(&FullRange) { "32" => (ast::TyI32, ast::TyU32), "64" => (ast::TyI64, ast::TyU64), w => sp.handler().fatal((format!("target specification was invalid: unrecognized \ - target-word-size {}", w))[]) + target-word-size {}", w)).index(&FullRange)) }; Config { @@ -845,7 +845,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let unparsed_crate_types = matches.opt_strs("crate-type"); let crate_types = parse_crate_types_from_list(unparsed_crate_types) - .unwrap_or_else(|e| early_error(e[])); + .unwrap_or_else(|e| early_error(e.index(&FullRange))); let mut lint_opts = vec!(); let mut describe_lints = false; @@ -873,7 +873,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } if this_bit == 0 { early_error(format!("unknown debug flag: {}", - *debug_flag)[]) + *debug_flag).index(&FullRange)) } debugging_opts |= this_bit; } @@ -918,7 +918,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { "dep-info" => OutputTypeDepInfo, _ => { early_error(format!("unknown emission type: `{}`", - part)[]) + part).index(&FullRange)) } }; output_types.push(output_type) @@ -957,7 +957,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { Some(arg) => { early_error(format!("optimization level needs to be \ between 0-3 (instead was `{}`)", - arg)[]); + arg).index(&FullRange)); } } } else { @@ -995,7 +995,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { Some(arg) => { early_error(format!("debug info level needs to be between \ 0-2 (instead was `{}`)", - arg)[]); + arg).index(&FullRange)); } } } else { @@ -1013,7 +1013,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut search_paths = SearchPaths::new(); for s in matches.opt_strs("L").iter() { - search_paths.add_path(s[]); + search_paths.add_path(s.index(&FullRange)); } let libs = matches.opt_strs("l").into_iter().map(|s| { @@ -1045,7 +1045,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { (_, s) => { early_error(format!("unknown library kind `{}`, expected \ one of dylib, framework, or static", - s)[]); + s).index(&FullRange)); } }; (name.to_string(), kind) @@ -1089,7 +1089,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { --debuginfo"); } - let color = match matches.opt_str("color").as_ref().map(|s| s[]) { + let color = match matches.opt_str("color").as_ref().map(|s| s.index(&FullRange)) { Some("auto") => Auto, Some("always") => Always, Some("never") => Never, @@ -1099,7 +1099,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { Some(arg) => { early_error(format!("argument for --color must be auto, always \ or never (instead was `{}`)", - arg)[]) + arg).index(&FullRange)) } }; @@ -1201,7 +1201,7 @@ mod test { #[test] fn test_switch_implies_cfg_test() { let matches = - &match getopts(&["--test".to_string()], optgroups()[]) { + &match getopts(&["--test".to_string()], optgroups().index(&FullRange)) { Ok(m) => m, Err(f) => panic!("test_switch_implies_cfg_test: {}", f) }; @@ -1209,7 +1209,7 @@ mod test { let sessopts = build_session_options(matches); let sess = build_session(sessopts, None, registry); let cfg = build_configuration(&sess); - assert!((attr::contains_name(cfg[], "test"))); + assert!((attr::contains_name(cfg.index(&FullRange), "test"))); } // When the user supplies --test and --cfg test, don't implicitly add @@ -1218,7 +1218,7 @@ mod test { fn test_switch_implies_cfg_test_unless_cfg_test() { let matches = &match getopts(&["--test".to_string(), "--cfg=test".to_string()], - optgroups()[]) { + optgroups().index(&FullRange)) { Ok(m) => m, Err(f) => { panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f) @@ -1238,7 +1238,7 @@ mod test { { let matches = getopts(&[ "-Awarnings".to_string() - ], optgroups()[]).unwrap(); + ], optgroups().index(&FullRange)).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); @@ -1249,7 +1249,7 @@ mod test { let matches = getopts(&[ "-Awarnings".to_string(), "-Dwarnings".to_string() - ], optgroups()[]).unwrap(); + ], optgroups().index(&FullRange)).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); @@ -1259,7 +1259,7 @@ mod test { { let matches = getopts(&[ "-Adead_code".to_string() - ], optgroups()[]).unwrap(); + ], optgroups().index(&FullRange)).unwrap(); let registry = diagnostics::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, None, registry); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index abb780615ae7b..94a6bca4e06e5 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -174,7 +174,7 @@ impl Session { // cases later on pub fn impossible_case(&self, sp: Span, msg: &str) -> ! { self.span_bug(sp, - format!("impossible case reached: {}", msg)[]); + format!("impossible case reached: {}", msg).index(&FullRange)); } pub fn verbose(&self) -> bool { self.debugging_opt(config::VERBOSE) } pub fn time_passes(&self) -> bool { self.debugging_opt(config::TIME_PASSES) } @@ -216,7 +216,7 @@ impl Session { } pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch { filesearch::FileSearch::new(self.sysroot(), - self.opts.target_triple[], + self.opts.target_triple.index(&FullRange), &self.opts.search_paths, kind) } diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs index 79bd0d4e306e4..8f5820d92c589 100644 --- a/src/librustc/util/lev_distance.rs +++ b/src/librustc/util/lev_distance.rs @@ -48,7 +48,7 @@ fn test_lev_distance() { for c in range(0u32, MAX as u32) .filter_map(|i| from_u32(i)) .map(|i| i.to_string()) { - assert_eq!(lev_distance(c[], c[]), 0); + assert_eq!(lev_distance(c.index(&FullRange), c.index(&FullRange)), 0); } let a = "\nMäry häd ä little lämb\n\nLittle lämb\n"; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 8c2a9993004d9..55bba3e4215d6 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -55,12 +55,12 @@ pub fn note_and_explain_region(cx: &ctxt, (ref str, Some(span)) => { cx.sess.span_note( span, - format!("{}{}{}", prefix, *str, suffix)[]); + format!("{}{}{}", prefix, *str, suffix).index(&FullRange)); Some(span) } (ref str, None) => { cx.sess.note( - format!("{}{}{}", prefix, *str, suffix)[]); + format!("{}{}{}", prefix, *str, suffix).index(&FullRange)); None } } @@ -271,7 +271,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { }; if abi != abi::Rust { - s.push_str(format!("extern {} ", abi.to_string())[]); + s.push_str(format!("extern {} ", abi.to_string()).index(&FullRange)); }; s.push_str("fn"); @@ -290,7 +290,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { Some(def_id) => { s.push_str(" {"); let path_str = ty::item_path_str(cx, def_id); - s.push_str(path_str[]); + s.push_str(path_str.index(&FullRange)); s.push_str("}"); } None => { } @@ -305,7 +305,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { match cty.store { ty::UniqTraitStore => {} ty::RegionTraitStore(region, _) => { - s.push_str(region_to_string(cx, "", true, region)[]); + s.push_str(region_to_string(cx, "", true, region).index(&FullRange)); } } @@ -324,7 +324,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { assert_eq!(cty.onceness, ast::Once); s.push_str("proc"); push_sig_to_string(cx, &mut s, '(', ')', &cty.sig, - bounds_str[]); + bounds_str.index(&FullRange)); } ty::RegionTraitStore(..) => { match cty.onceness { @@ -332,7 +332,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { ast::Once => s.push_str("once ") } push_sig_to_string(cx, &mut s, '|', '|', &cty.sig, - bounds_str[]); + bounds_str.index(&FullRange)); } } @@ -365,7 +365,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { ty::FnConverging(t) => { if !ty::type_is_nil(t) { s.push_str(" -> "); - s.push_str(ty_to_string(cx, t)[]); + s.push_str(ty_to_string(cx, t).index(&FullRange)); } } ty::FnDiverging => { @@ -402,7 +402,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { } ty_rptr(r, ref tm) => { let mut buf = region_ptr_to_string(cx, *r); - buf.push_str(mt_to_string(cx, tm)[]); + buf.push_str(mt_to_string(cx, tm).index(&FullRange)); buf } ty_open(typ) => @@ -412,7 +412,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { .iter() .map(|elem| ty_to_string(cx, *elem)) .collect::>(); - match strs[] { + match strs.index(&FullRange) { [ref string] => format!("({},)", string), strs => format!("({})", strs.connect(", ")) } @@ -541,7 +541,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, 0 }; - for t in tps[..tps.len() - num_defaults].iter() { + for t in tps.index(&(0..(tps.len() - num_defaults))).iter() { strs.push(ty_to_string(cx, *t)) } @@ -549,11 +549,11 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, format!("{}({}){}", base, if strs[0].starts_with("(") && strs[0].ends_with(",)") { - strs[0][1 .. strs[0].len() - 2] // Remove '(' and ',)' + strs[0].index(&(1 .. (strs[0].len() - 2))) // Remove '(' and ',)' } else if strs[0].starts_with("(") && strs[0].ends_with(")") { - strs[0][1 .. strs[0].len() - 1] // Remove '(' and ')' + strs[0].index(&(1 .. (strs[0].len() - 1))) // Remove '(' and ')' } else { - strs[0][] + strs[0].index(&FullRange) }, if &*strs[1] == "()" { String::new() } else { format!(" -> {}", strs[1]) }) } else if strs.len() > 0 { @@ -566,7 +566,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String { let mut s = typ.repr(cx).to_string(); if s.len() >= 32u { - s = s[0u..32u].to_string(); + s = s.index(&(0u..32u)).to_string(); } return s; } @@ -631,7 +631,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for [T] { impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - repr_vec(tcx, self[]) + repr_vec(tcx, self.index(&FullRange)) } } @@ -639,7 +639,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice { // autoderef cannot convert the &[T] handler impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for Vec { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - repr_vec(tcx, self[]) + repr_vec(tcx, self.index(&FullRange)) } } diff --git a/src/librustc/util/snapshot_vec.rs b/src/librustc/util/snapshot_vec.rs index 11820c908eeba..6040f55ceeba0 100644 --- a/src/librustc/util/snapshot_vec.rs +++ b/src/librustc/util/snapshot_vec.rs @@ -116,7 +116,7 @@ impl> SnapshotVec { pub fn actions_since_snapshot(&self, snapshot: &Snapshot) -> &[UndoLog] { - self.undo_log[snapshot.length..] + self.undo_log.index(&(snapshot.length..)) } fn assert_open_snapshot(&self, snapshot: &Snapshot) { diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index 0bd4265e487a6..5a5a310c56dee 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -53,7 +53,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option, args: &str, cwd: Option<&Path>, paths: &[&Path]) -> ProcessOutput { let ar = match *maybe_ar_prog { - Some(ref ar) => ar[], + Some(ref ar) => ar.index(&FullRange), None => "ar" }; let mut cmd = Command::new(ar); @@ -75,22 +75,22 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option, if !o.status.success() { handler.err(format!("{} failed with: {}", cmd, - o.status)[]); + o.status).index(&FullRange)); handler.note(format!("stdout ---\n{}", str::from_utf8(o.output - []).unwrap()) - []); + .index(&FullRange)).unwrap()) + .index(&FullRange)); handler.note(format!("stderr ---\n{}", str::from_utf8(o.error - []).unwrap()) - []); + .index(&FullRange)).unwrap()) + .index(&FullRange)); handler.abort_if_errors(); } o }, Err(e) => { - handler.err(format!("could not exec `{}`: {}", ar[], - e)[]); + handler.err(format!("could not exec `{}`: {}", ar.index(&FullRange), + e).index(&FullRange)); handler.abort_if_errors(); panic!("rustc::back::archive::run_ar() should not reach this point"); } @@ -106,16 +106,16 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str, for path in search_paths.iter() { debug!("looking for {} inside {}", name, path.display()); - let test = path.join(oslibname[]); + let test = path.join(oslibname.index(&FullRange)); if test.exists() { return test } if oslibname != unixlibname { - let test = path.join(unixlibname[]); + let test = path.join(unixlibname.index(&FullRange)); if test.exists() { return test } } } handler.fatal(format!("could not find native static library `{}`, \ perhaps an -L flag is missing?", - name)[]); + name).index(&FullRange)); } impl<'a> Archive<'a> { @@ -147,7 +147,7 @@ impl<'a> Archive<'a> { /// Lists all files in an archive pub fn files(&self) -> Vec { let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, &[&self.dst]); - let output = str::from_utf8(output.output[]).unwrap(); + let output = str::from_utf8(output.output.index(&FullRange)).unwrap(); // use lines_any because windows delimits output with `\r\n` instead of // just `\n` output.lines_any().map(|s| s.to_string()).collect() @@ -179,9 +179,9 @@ impl<'a> ArchiveBuilder<'a> { /// search in the relevant locations for a library named `name`. pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> { let location = find_library(name, - self.archive.slib_prefix[], - self.archive.slib_suffix[], - self.archive.lib_search_paths[], + self.archive.slib_prefix.index(&FullRange), + self.archive.slib_suffix.index(&FullRange), + self.archive.lib_search_paths.index(&FullRange), self.archive.handler); self.add_archive(&location, name, |_| false) } @@ -197,12 +197,12 @@ impl<'a> ArchiveBuilder<'a> { // as simple comparison is not enough - there // might be also an extra name suffix let obj_start = format!("{}", name); - let obj_start = obj_start[]; + let obj_start = obj_start.index(&FullRange); // Ignoring all bytecode files, no matter of // name let bc_ext = ".bytecode.deflate"; - self.add_archive(rlib, name[], |fname: &str| { + self.add_archive(rlib, name.index(&FullRange), |fname: &str| { let skip_obj = lto && fname.starts_with(obj_start) && fname.ends_with(".o"); skip_obj || fname.ends_with(bc_ext) || fname == METADATA_FILENAME @@ -239,7 +239,7 @@ impl<'a> ArchiveBuilder<'a> { // allow running `ar s file.a` to update symbols only. if self.should_update_symbols { run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - "s", Some(self.work_dir.path()), args[]); + "s", Some(self.work_dir.path()), args.index(&FullRange)); } return self.archive; } @@ -259,7 +259,7 @@ impl<'a> ArchiveBuilder<'a> { // Add the archive members seen so far, without updating the // symbol table (`S`). run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - "cruS", Some(self.work_dir.path()), args[]); + "cruS", Some(self.work_dir.path()), args.index(&FullRange)); args.clear(); args.push(&abs_dst); @@ -274,7 +274,7 @@ impl<'a> ArchiveBuilder<'a> { // necessary. let flags = if self.should_update_symbols { "crus" } else { "cruS" }; run_ar(self.archive.handler, &self.archive.maybe_ar_prog, - flags, Some(self.work_dir.path()), args[]); + flags, Some(self.work_dir.path()), args.index(&FullRange)); self.archive } @@ -316,7 +316,7 @@ impl<'a> ArchiveBuilder<'a> { } else { filename }; - let new_filename = self.work_dir.path().join(filename[]); + let new_filename = self.work_dir.path().join(filename.index(&FullRange)); try!(fs::rename(file, &new_filename)); self.members.push(Path::new(filename)); } diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 955081a3af64c..b6f080094cfba 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -44,15 +44,15 @@ pub fn get_rpath_flags(config: RPathConfig) -> Vec where l.map(|p| p.clone()) }).collect::>(); - let rpaths = get_rpaths(config, libs[]); - flags.push_all(rpaths_to_flags(rpaths[])[]); + let rpaths = get_rpaths(config, libs.index(&FullRange)); + flags.push_all(rpaths_to_flags(rpaths.index(&FullRange)).index(&FullRange)); flags } fn rpaths_to_flags(rpaths: &[String]) -> Vec { let mut ret = Vec::new(); for rpath in rpaths.iter() { - ret.push(format!("-Wl,-rpath,{}", (*rpath)[])); + ret.push(format!("-Wl,-rpath,{}", (*rpath).index(&FullRange))); } return ret; } @@ -82,14 +82,14 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec } } - log_rpaths("relative", rel_rpaths[]); - log_rpaths("fallback", fallback_rpaths[]); + log_rpaths("relative", rel_rpaths.index(&FullRange)); + log_rpaths("fallback", fallback_rpaths.index(&FullRange)); let mut rpaths = rel_rpaths; - rpaths.push_all(fallback_rpaths[]); + rpaths.push_all(fallback_rpaths.index(&FullRange)); // Remove duplicates - let rpaths = minimize_rpaths(rpaths[]); + let rpaths = minimize_rpaths(rpaths.index(&FullRange)); return rpaths; } @@ -140,7 +140,7 @@ fn minimize_rpaths(rpaths: &[String]) -> Vec { let mut set = HashSet::new(); let mut minimized = Vec::new(); for rpath in rpaths.iter() { - if set.insert(rpath[]) { + if set.insert(rpath.index(&FullRange)) { minimized.push(rpath.clone()); } } diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index d606c5158d0f7..f33971a6ac0c2 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -140,7 +140,7 @@ impl FixedBuffer for FixedBuffer64 { if input.len() >= buffer_remaining { copy_memory( self.buffer.slice_mut(self.buffer_idx, size), - input[..buffer_remaining]); + input.index(&(0..buffer_remaining))); self.buffer_idx = 0; func(&self.buffer); i += buffer_remaining; @@ -156,7 +156,7 @@ impl FixedBuffer for FixedBuffer64 { // While we have at least a full buffer size chunk's worth of data, process that data // without copying it into the buffer while input.len() - i >= size { - func(input[i..i + size]); + func(input.index(&(i..(i + size)))); i += size; } @@ -166,7 +166,7 @@ impl FixedBuffer for FixedBuffer64 { let input_remaining = input.len() - i; copy_memory( self.buffer.slice_to_mut(input_remaining), - input[i..]); + input.index(&(i..))); self.buffer_idx += input_remaining; } @@ -188,7 +188,7 @@ impl FixedBuffer for FixedBuffer64 { fn full_buffer<'s>(&'s mut self) -> &'s [u8] { assert!(self.buffer_idx == 64); self.buffer_idx = 0; - return self.buffer[..64]; + return self.buffer.index(&(0..64)); } fn position(&self) -> uint { self.buffer_idx } diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 86bd74d3f85e5..00f1f2402c76e 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -65,7 +65,7 @@ impl Svh { } pub fn as_str<'a>(&'a self) -> &'a str { - self.hash[] + self.hash.index(&FullRange) } pub fn calculate(metadata: &Vec, krate: &ast::Crate) -> Svh { @@ -358,7 +358,7 @@ mod svh_visitor { fn macro_name(mac: &Mac) -> token::InternedString { match &mac.node { &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => { - let s = path.segments[]; + let s = path.segments.index(&FullRange); assert_eq!(s.len(), 1); content(s[0].identifier) } diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index f14583bb9aa81..5f5ad7efdf1bf 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -225,7 +225,7 @@ impl Target { Some(val) => val, None => handler.fatal((format!("Field {} in target specification is required", name)) - []) + .index(&FullRange)) } }; @@ -242,16 +242,16 @@ impl Target { macro_rules! key { ($key_name:ident) => ( { let name = (stringify!($key_name)).replace("_", "-"); - obj.find(name[]).map(|o| o.as_string() + obj.find(name.index(&FullRange)).map(|o| o.as_string() .map(|s| base.options.$key_name = s.to_string())); } ); ($key_name:ident, bool) => ( { let name = (stringify!($key_name)).replace("_", "-"); - obj.find(name[]).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("_", "-"); - obj.find(name[]).map(|o| o.as_array() + obj.find(name.index(&FullRange)).map(|o| o.as_array() .map(|v| base.options.$key_name = v.iter() .map(|a| a.as_string().unwrap().to_string()).collect() ) @@ -367,7 +367,7 @@ impl Target { let target_path = os::getenv("RUST_TARGET_PATH").unwrap_or(String::new()); - let paths = os::split_paths(target_path[]); + let paths = os::split_paths(target_path.index(&FullRange)); // FIXME 16351: add a sane default search path? for dir in paths.iter() { diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index cb77519671cf5..837630c0d61ea 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -465,7 +465,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { new_loan.span, format!("cannot borrow `{}`{} as mutable \ more than once at a time", - nl, new_loan_msg)[]) + nl, new_loan_msg).index(&FullRange)) } (ty::UniqueImmBorrow, _) => { @@ -473,7 +473,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { new_loan.span, format!("closure requires unique access to `{}` \ but {} is already borrowed{}", - nl, ol_pronoun, old_loan_msg)[]); + nl, ol_pronoun, old_loan_msg).index(&FullRange)); } (_, ty::UniqueImmBorrow) => { @@ -481,7 +481,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { new_loan.span, format!("cannot borrow `{}`{} as {} because \ previous closure requires unique access", - nl, new_loan_msg, new_loan.kind.to_user_str())[]); + nl, new_loan_msg, new_loan.kind.to_user_str()).index(&FullRange)); } (_, _) => { @@ -494,7 +494,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { new_loan.kind.to_user_str(), ol_pronoun, old_loan.kind.to_user_str(), - old_loan_msg)[]); + old_loan_msg).index(&FullRange)); } } @@ -503,7 +503,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_note( span, format!("borrow occurs due to use of `{}` in closure", - nl)[]); + nl).index(&FullRange)); } _ => { } } @@ -552,7 +552,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_note( old_loan.span, - format!("{}; {}", borrow_summary, rule_summary)[]); + format!("{}; {}", borrow_summary, rule_summary).index(&FullRange)); let old_loan_span = self.tcx().map.span(old_loan.kill_scope.node_id()); self.bccx.span_end_note(old_loan_span, @@ -622,13 +622,13 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_err( span, format!("cannot use `{}` because it was mutably borrowed", - self.bccx.loan_path_to_string(copy_path)[]) - []); + self.bccx.loan_path_to_string(copy_path).index(&FullRange)) + .index(&FullRange)); self.bccx.span_note( loan_span, format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(&*loan_path)[]) - []); + self.bccx.loan_path_to_string(&*loan_path).index(&FullRange)) + .index(&FullRange)); } } } @@ -647,20 +647,20 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { let err_message = match move_kind { move_data::Captured => format!("cannot move `{}` into closure because it is borrowed", - self.bccx.loan_path_to_string(move_path)[]), + self.bccx.loan_path_to_string(move_path).index(&FullRange)), move_data::Declared | move_data::MoveExpr | move_data::MovePat => format!("cannot move out of `{}` because it is borrowed", - self.bccx.loan_path_to_string(move_path)[]) + self.bccx.loan_path_to_string(move_path).index(&FullRange)) }; - self.bccx.span_err(span, err_message[]); + self.bccx.span_err(span, err_message.index(&FullRange)); self.bccx.span_note( loan_span, format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(&*loan_path)[]) - []); + self.bccx.loan_path_to_string(&*loan_path).index(&FullRange)) + .index(&FullRange)); } } } @@ -810,7 +810,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_err( assignment_span, format!("cannot assign to {}", - self.bccx.cmt_to_string(&*assignee_cmt))[]); + self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); self.bccx.span_help( self.tcx().map.span(upvar_id.closure_expr_id), "consider changing this closure to take self by mutable reference"); @@ -819,7 +819,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { assignment_span, format!("cannot assign to {} {}", assignee_cmt.mutbl.to_user_str(), - self.bccx.cmt_to_string(&*assignee_cmt))[]); + self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); } } _ => match opt_loan_path(&assignee_cmt) { @@ -829,14 +829,14 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { format!("cannot assign to {} {} `{}`", assignee_cmt.mutbl.to_user_str(), self.bccx.cmt_to_string(&*assignee_cmt), - self.bccx.loan_path_to_string(&*lp))[]); + self.bccx.loan_path_to_string(&*lp)).index(&FullRange)); } None => { self.bccx.span_err( assignment_span, format!("cannot assign to {} {}", assignee_cmt.mutbl.to_user_str(), - self.bccx.cmt_to_string(&*assignee_cmt))[]); + self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange)); } } } @@ -956,10 +956,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { self.bccx.span_err( span, format!("cannot assign to `{}` because it is borrowed", - self.bccx.loan_path_to_string(loan_path))[]); + self.bccx.loan_path_to_string(loan_path)).index(&FullRange)); self.bccx.span_note( loan.span, format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_string(loan_path))[]); + self.bccx.loan_path_to_string(loan_path)).index(&FullRange)); } } diff --git a/src/librustc_borrowck/borrowck/doc.rs b/src/librustc_borrowck/borrowck/doc.rs index ac2ab56b2c5f8..e309ba0a6348e 100644 --- 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, [])`, +//! restriction. This implies that the "empty restriction" `(LV, .index(&FullRange))`, //! 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, []) +//! &const LV => RESTRICTIONS(LV, LT, .index(&FullRange)) //! ``` //! //! 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) = [] // R-Deref-Imm-Borrowed +//! RESTRICTIONS(*LV, LT, ACTIONS) = .index(&FullRange) // R-Deref-Imm-Borrowed //! TYPE(LV) = <' 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, []) = [] // R-Deref-Freeze-Borrowed +//! RESTRICTIONS(*LV, LT, .index(&FullRange)) = .index(&FullRange) // R-Deref-Freeze-Borrowed //! TYPE(LV) = &const Ty //! ``` //! diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 0d86811af9f49..8b4029f30d93f 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -38,7 +38,7 @@ enum Fragment { // This represents the collection of all but one of the elements // from an array at the path described by the move path index. // Note that attached MovePathIndex should have mem_categorization - // of InteriorElement (i.e. array dereference `[]`). + // of InteriorElement (i.e. array dereference `.index(&FullRange)`). AllButOneFrom(MovePathIndex), } @@ -123,12 +123,12 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, let attrs : &[ast::Attribute]; attrs = match tcx.map.find(id) { Some(ast_map::NodeItem(ref item)) => - item.attrs[], + item.attrs.index(&FullRange), Some(ast_map::NodeImplItem(&ast::MethodImplItem(ref m))) => - m.attrs[], + m.attrs.index(&FullRange), Some(ast_map::NodeTraitItem(&ast::ProvidedMethod(ref m))) => - m.attrs[], - _ => [][], + m.attrs.index(&FullRange), + _ => [].index(&FullRange), }; let span_err = @@ -144,7 +144,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, for (i, mpi) in vec_rc.iter().enumerate() { let render = |&:| this.path_loan_path(*mpi).user_string(tcx); if span_err { - tcx.sess.span_err(sp, format!("{}: `{}`", kind, render())[]); + tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange)); } if print { println!("id:{} {}[{}] `{}`", id, kind, i, render()); @@ -156,7 +156,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>, for (i, f) in vec_rc.iter().enumerate() { let render = |&:| f.loan_path_user_string(this, tcx); if span_err { - tcx.sess.span_err(sp, format!("{}: `{}`", kind, render())[]); + tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange)); } if print { println!("id:{} {}[{}] `{}`", id, kind, i, render()); @@ -198,11 +198,11 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { // First, filter out duplicates moved.sort(); moved.dedup(); - debug!("fragments 1 moved: {}", path_lps(moved[])); + debug!("fragments 1 moved: {}", path_lps(moved.index(&FullRange))); assigned.sort(); assigned.dedup(); - debug!("fragments 1 assigned: {}", path_lps(assigned[])); + debug!("fragments 1 assigned: {}", path_lps(assigned.index(&FullRange))); // Second, build parents from the moved and assigned. for m in moved.iter() { @@ -222,14 +222,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { parents.sort(); parents.dedup(); - debug!("fragments 2 parents: {}", path_lps(parents[])); + debug!("fragments 2 parents: {}", path_lps(parents.index(&FullRange))); // Third, filter the moved and assigned fragments down to just the non-parents - moved.retain(|f| non_member(*f, parents[])); - debug!("fragments 3 moved: {}", path_lps(moved[])); + moved.retain(|f| non_member(*f, parents.index(&FullRange))); + debug!("fragments 3 moved: {}", path_lps(moved.index(&FullRange))); - assigned.retain(|f| non_member(*f, parents[])); - debug!("fragments 3 assigned: {}", path_lps(assigned[])); + assigned.retain(|f| non_member(*f, parents.index(&FullRange))); + debug!("fragments 3 assigned: {}", path_lps(assigned.index(&FullRange))); // Fourth, build the leftover from the moved, assigned, and parents. for m in moved.iter() { @@ -247,16 +247,16 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { unmoved.sort(); unmoved.dedup(); - debug!("fragments 4 unmoved: {}", frag_lps(unmoved[])); + debug!("fragments 4 unmoved: {}", frag_lps(unmoved.index(&FullRange))); // Fifth, filter the leftover fragments down to its core. unmoved.retain(|f| match *f { AllButOneFrom(_) => true, - Just(mpi) => non_member(mpi, parents[]) && - non_member(mpi, moved[]) && - non_member(mpi, assigned[]) + Just(mpi) => non_member(mpi, parents.index(&FullRange)) && + non_member(mpi, moved.index(&FullRange)) && + non_member(mpi, assigned.index(&FullRange)) }); - debug!("fragments 5 unmoved: {}", frag_lps(unmoved[])); + debug!("fragments 5 unmoved: {}", frag_lps(unmoved.index(&FullRange))); // Swap contents back in. fragments.unmoved_fragments = unmoved; @@ -433,7 +433,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, let msg = format!("type {} ({}) is not fragmentable", parent_ty.repr(tcx), sty_and_variant_info); let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id)); - tcx.sess.opt_span_bug(opt_span, msg[]) + tcx.sess.opt_span_bug(opt_span, msg.index(&FullRange)) } } } diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index 1e9e5b22aa0ed..86498af7d950c 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -307,7 +307,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { self.tcx().sess.span_bug( cmt.span, format!("invalid borrow lifetime: {}", - loan_region)[]); + loan_region).index(&FullRange)); } }; debug!("loan_scope = {}", loan_scope); diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 95c5d9415a125..1bb143e1dc8d3 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -120,7 +120,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, bccx.span_err( move_from.span, format!("cannot move out of {}", - bccx.cmt_to_string(&*move_from))[]); + bccx.cmt_to_string(&*move_from)).index(&FullRange)); } mc::cat_downcast(ref b, _) | @@ -132,7 +132,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, move_from.span, format!("cannot move out of type `{}`, \ which defines the `Drop` trait", - b.ty.user_string(bccx.tcx))[]); + b.ty.user_string(bccx.tcx)).index(&FullRange)); }, _ => panic!("this path should not cause illegal move") } @@ -155,10 +155,10 @@ fn note_move_destination(bccx: &BorrowckCtxt, format!("to prevent the move, \ use `ref {0}` or `ref mut {0}` to capture value by \ reference", - pat_name)[]); + pat_name).index(&FullRange)); } else { bccx.span_note(move_to_span, format!("and here (use `ref {0}` or `ref mut {0}`)", - pat_name)[]); + pat_name).index(&FullRange)); } } diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 20949151557cb..36e1a4861120c 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -137,7 +137,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt, check_loans::check_loans(this, &loan_dfcx, flowed_moves, - all_loans[], + all_loans.index(&FullRange), id, decl, body); @@ -505,7 +505,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { pub fn report(&self, err: BckError<'tcx>) { self.span_err( err.span, - self.bckerr_to_string(&err)[]); + self.bckerr_to_string(&err).index(&FullRange)); self.note_and_explain_bckerr(err); } @@ -527,7 +527,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { use_span, format!("{} of possibly uninitialized variable: `{}`", verb, - self.loan_path_to_string(lp))[]); + self.loan_path_to_string(lp)).index(&FullRange)); (self.loan_path_to_string(moved_lp), String::new()) } @@ -569,7 +569,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { format!("{} of {}moved value: `{}`", verb, msg, - nl)[]); + nl).index(&FullRange)); (ol, moved_lp_msg) } }; @@ -588,7 +588,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { self.tcx.sess.bug(format!("MoveExpr({}) maps to \ {}, not Expr", the_move.id, - r)[]) + r).index(&FullRange)) } }; let (suggestion, _) = @@ -599,7 +599,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { ol, moved_lp_msg, expr_ty.user_string(self.tcx), - suggestion)[]); + suggestion).index(&FullRange)); } move_data::MovePat => { @@ -610,7 +610,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { which is moved by default", ol, moved_lp_msg, - pat_ty.user_string(self.tcx))[]); + pat_ty.user_string(self.tcx)).index(&FullRange)); self.tcx.sess.span_help(span, "use `ref` to override"); } @@ -626,7 +626,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { self.tcx.sess.bug(format!("Captured({}) maps to \ {}, not Expr", the_move.id, - r)[]) + r).index(&FullRange)) } }; let (suggestion, help) = @@ -642,7 +642,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { ol, moved_lp_msg, expr_ty.user_string(self.tcx), - suggestion)[]); + suggestion).index(&FullRange)); self.tcx.sess.span_help(expr_span, help); } } @@ -673,7 +673,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, format!("re-assignment of immutable variable `{}`", - self.loan_path_to_string(lp))[]); + self.loan_path_to_string(lp)).index(&FullRange)); self.tcx.sess.span_note(assign.span, "prior assignment occurs here"); } @@ -799,12 +799,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, format!("{} in an aliasable location", - prefix)[]); + prefix).index(&FullRange)); } mc::AliasableClosure(id) => { self.tcx.sess.span_err(span, format!("{} in a captured outer \ - variable in an `Fn` closure", prefix)[]); + variable in an `Fn` closure", prefix).index(&FullRange)); span_help!(self.tcx.sess, self.tcx.map.span(id), "consider changing this closure to take self by mutable reference"); } @@ -812,12 +812,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { mc::AliasableStaticMut(..) => { self.tcx.sess.span_err( span, - format!("{} in a static location", prefix)[]); + format!("{} in a static location", prefix).index(&FullRange)); } mc::AliasableBorrowed => { self.tcx.sess.span_err( span, - format!("{} in a `&` reference", prefix)[]); + format!("{} in a `&` reference", prefix).index(&FullRange)); } } @@ -885,12 +885,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { note_and_explain_region( self.tcx, format!("{} would have to be valid for ", - descr)[], + descr).index(&FullRange), loan_scope, "..."); note_and_explain_region( self.tcx, - format!("...but {} is only valid for ", descr)[], + format!("...but {} is only valid for ", descr).index(&FullRange), ptr_scope, ""); } @@ -910,7 +910,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { out.push('('); self.append_loan_path_to_string(&**lp_base, out); out.push_str(DOWNCAST_PRINTED_OPERATOR); - out.push_str(ty::item_path_str(self.tcx, variant_def_id)[]); + out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange)); out.push(')'); } @@ -924,7 +924,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } mc::PositionalField(idx) => { out.push('.'); - out.push_str(idx.to_string()[]); + out.push_str(idx.to_string().index(&FullRange)); } } } @@ -956,7 +956,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { out.push('('); self.append_autoderefd_loan_path_to_string(&**lp_base, out); out.push(':'); - out.push_str(ty::item_path_str(self.tcx, variant_def_id)[]); + out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange)); out.push(')'); } diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index f2c35851d0d7c..648b389414a56 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -60,7 +60,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { if seen_one { sets.push_str(" "); } else { seen_one = true; } sets.push_str(variant.short_name()); sets.push_str(": "); - sets.push_str(self.dataflow_for_variant(e, n, variant)[]); + sets.push_str(self.dataflow_for_variant(e, n, variant).index(&FullRange)); } sets } @@ -89,7 +89,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { set.push_str(", "); } let loan_str = self.borrowck_ctxt.loan_path_to_string(&*lp); - set.push_str(loan_str[]); + set.push_str(loan_str.index(&FullRange)); saw_some = true; true }); @@ -101,7 +101,8 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { let dfcx = &self.analysis_data.loans; let loan_index_to_path = |&mut: loan_index| { let all_loans = &self.analysis_data.all_loans; - all_loans[loan_index].loan_path() + let l: &borrowck::Loan = &all_loans[loan_index]; + l.loan_path() }; self.build_set(e, cfgidx, dfcx, loan_index_to_path) } @@ -111,7 +112,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { let move_index_to_path = |&mut: move_index| { let move_data = &self.analysis_data.move_data.move_data; let moves = move_data.moves.borrow(); - let the_move = &(*moves)[move_index]; + let the_move: &borrowck::move_data::Move = &(*moves)[move_index]; move_data.path_loan_path(the_move.path) }; self.build_set(e, cfgidx, dfcx, move_index_to_path) @@ -122,7 +123,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { let assign_index_to_path = |&mut: assign_index| { let move_data = &self.analysis_data.move_data.move_data; let assignments = move_data.var_assignments.borrow(); - let assignment = &(*assignments)[assign_index]; + let assignment: &borrowck::move_data::Assignment = &(*assignments)[assign_index]; move_data.path_loan_path(assignment.path) }; self.build_set(e, cfgidx, dfcx, assign_index_to_path) diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 74f81ae9d6d1e..baeca7c8ffdbb 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -58,12 +58,12 @@ pub fn compile_input(sess: Session, let outputs = build_output_filenames(input, outdir, output, - krate.attrs[], + krate.attrs.index(&FullRange), &sess); - let id = link::find_crate_name(Some(&sess), krate.attrs[], + let id = link::find_crate_name(Some(&sess), krate.attrs.index(&FullRange), input); let expanded_crate - = match phase_2_configure_and_expand(&sess, krate, id[], + = match phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), addl_plugins) { None => return, Some(k) => k @@ -75,7 +75,7 @@ pub fn compile_input(sess: Session, let mut forest = ast_map::Forest::new(expanded_crate); let ast_map = assign_node_ids_and_map(&sess, &mut forest); - write_out_deps(&sess, input, &outputs, id[]); + write_out_deps(&sess, input, &outputs, id.index(&FullRange)); if stop_after_phase_2(&sess) { return; } @@ -171,9 +171,9 @@ pub fn phase_2_configure_and_expand(sess: &Session, let time_passes = sess.time_passes(); *sess.crate_types.borrow_mut() = - collect_crate_types(sess, krate.attrs[]); + collect_crate_types(sess, krate.attrs.index(&FullRange)); *sess.crate_metadata.borrow_mut() = - collect_crate_metadata(sess, krate.attrs[]); + collect_crate_metadata(sess, krate.attrs.index(&FullRange)); time(time_passes, "recursion limit", (), |_| { middle::recursion_limit::update_recursion_limit(sess, &krate); @@ -268,8 +268,8 @@ pub fn phase_2_configure_and_expand(sess: &Session, if cfg!(windows) { _old_path = os::getenv("PATH").unwrap_or(_old_path); let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths(); - new_path.extend(os::split_paths(_old_path[]).into_iter()); - os::setenv("PATH", os::join_paths(new_path[]).unwrap()); + new_path.extend(os::split_paths(_old_path.index(&FullRange)).into_iter()); + os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap()); } let cfg = syntax::ext::expand::ExpansionConfig { crate_name: crate_name.to_string(), @@ -533,7 +533,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session, time(sess.time_passes(), "LLVM passes", (), |_| write::run_passes(sess, trans, - sess.opts.output_types[], + sess.opts.output_types.index(&FullRange), outputs)); } @@ -547,14 +547,14 @@ pub fn phase_6_link_output(sess: &Session, outputs: &OutputFilenames) { let old_path = os::getenv("PATH").unwrap_or_else(||String::new()); let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths(); - new_path.extend(os::split_paths(old_path[]).into_iter()); - os::setenv("PATH", os::join_paths(new_path[]).unwrap()); + new_path.extend(os::split_paths(old_path.index(&FullRange)).into_iter()); + os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap()); time(sess.time_passes(), "linking", (), |_| link::link_binary(sess, trans, outputs, - trans.link.crate_name[])); + trans.link.crate_name.index(&FullRange))); os::setenv("PATH", old_path); } @@ -643,7 +643,7 @@ fn write_out_deps(sess: &Session, // write Makefile-compatible dependency rules let files: Vec = sess.codemap().files.borrow() .iter().filter(|fmap| fmap.is_real_file()) - .map(|fmap| escape_dep_filename(fmap.name[])) + .map(|fmap| escape_dep_filename(fmap.name.index(&FullRange))) .collect(); let mut file = try!(io::File::create(&deps_filename)); for path in out_filenames.iter() { @@ -657,7 +657,7 @@ fn write_out_deps(sess: &Session, Ok(()) => {} Err(e) => { sess.fatal(format!("error writing dependencies to `{}`: {}", - deps_filename.display(), e)[]); + deps_filename.display(), e).index(&FullRange)); } } } @@ -728,7 +728,7 @@ pub fn collect_crate_types(session: &Session, if !res { session.warn(format!("dropping unsupported crate type `{}` \ for target `{}`", - *crate_type, session.opts.target_triple)[]); + *crate_type, session.opts.target_triple).index(&FullRange)); } res diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 89b2e0f257acd..3fd5198ee4c4e 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -105,12 +105,12 @@ fn run_compiler(args: &[String]) { let descriptions = diagnostics::registry::Registry::new(&DIAGNOSTICS); match matches.opt_str("explain") { Some(ref code) => { - match descriptions.find_description(code[]) { + match descriptions.find_description(code.index(&FullRange)) { Some(ref description) => { println!("{}", description); } None => { - early_error(format!("no extended information for {}", code)[]); + early_error(format!("no extended information for {}", code).index(&FullRange)); } } return; @@ -136,7 +136,7 @@ fn run_compiler(args: &[String]) { early_error("no input filename given"); } 1u => { - let ifile = matches.free[0][]; + let ifile = matches.free[0].index(&FullRange); if ifile == "-" { let contents = io::stdin().read_to_end().unwrap(); let src = String::from_utf8(contents).unwrap(); @@ -313,7 +313,7 @@ Available lint options: for lint in lints.into_iter() { let name = lint.name_lower().replace("_", "-"); println!(" {} {:7.7} {}", - padded(name[]), lint.default_level.as_str(), lint.desc); + padded(name.index(&FullRange)), lint.default_level.as_str(), lint.desc); } println!("\n"); }; @@ -343,7 +343,7 @@ Available lint options: let desc = to.into_iter().map(|x| x.as_str().replace("_", "-")) .collect::>().connect(", "); println!(" {} {}", - padded(name[]), desc); + padded(name.index(&FullRange)), desc); } println!("\n"); }; @@ -409,7 +409,7 @@ pub fn handle_options(mut args: Vec) -> Option { } let matches = - match getopts::getopts(args[], config::optgroups()[]) { + match getopts::getopts(args.index(&FullRange), config::optgroups().index(&FullRange)) { Ok(m) => m, Err(f_stable_attempt) => { // redo option parsing, including unstable options this time, @@ -583,7 +583,7 @@ pub fn monitor(f: F) { "run with `RUST_BACKTRACE=1` for a backtrace".to_string(), ]; for note in xs.iter() { - emitter.emit(None, note[], None, diagnostic::Note) + emitter.emit(None, note.index(&FullRange), None, diagnostic::Note) } match r.read_to_string() { @@ -591,7 +591,7 @@ pub fn monitor(f: F) { Err(e) => { emitter.emit(None, format!("failed to read internal \ - stderr: {}", e)[], + stderr: {}", e).index(&FullRange), None, diagnostic::Error) } diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 61fd7d16ab7dd..06ef06a214f48 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -296,7 +296,7 @@ impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> { try!(pp::word(&mut s.s, ppaux::ty_to_string( tcx, - ty::expr_ty(tcx, expr))[])); + ty::expr_ty(tcx, expr)).index(&FullRange))); s.pclose() } _ => Ok(()) @@ -370,7 +370,7 @@ impl UserIdentifiedItem { ItemViaNode(node_id) => NodesMatchingDirect(Some(node_id).into_iter()), ItemViaPath(ref parts) => - NodesMatchingSuffix(map.nodes_matching_suffix(parts[])), + NodesMatchingSuffix(map.nodes_matching_suffix(parts.index(&FullRange))), } } @@ -382,7 +382,7 @@ impl UserIdentifiedItem { user_option, self.reconstructed_input(), is_wrong_because); - sess.fatal(message[]) + sess.fatal(message.index(&FullRange)) }; let mut saw_node = ast::DUMMY_NODE_ID; @@ -509,7 +509,7 @@ pub fn pretty_print_input(sess: Session, let is_expanded = needs_expansion(&ppm); let compute_ast_map = needs_ast_map(&ppm, &opt_uii); let krate = if compute_ast_map { - match driver::phase_2_configure_and_expand(&sess, krate, id[], None) { + match driver::phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), None) { None => return, Some(k) => k } @@ -528,7 +528,7 @@ pub fn pretty_print_input(sess: Session, }; let src_name = driver::source_name(input); - let src = sess.codemap().get_filemap(src_name[]) + let src = sess.codemap().get_filemap(src_name.index(&FullRange)) .src.as_bytes().to_vec(); let mut rdr = MemReader::new(src); @@ -589,7 +589,7 @@ pub fn pretty_print_input(sess: Session, debug!("pretty printing flow graph for {}", opt_uii); let uii = opt_uii.unwrap_or_else(|| { sess.fatal(format!("`pretty flowgraph=..` needs NodeId (int) or - unique path suffix (b::c::d)")[]) + unique path suffix (b::c::d)").index(&FullRange)) }); let ast_map = ast_map.expect("--pretty flowgraph missing ast_map"); @@ -597,7 +597,7 @@ pub fn pretty_print_input(sess: Session, let node = ast_map.find(nodeid).unwrap_or_else(|| { sess.fatal(format!("--pretty flowgraph couldn't find id: {}", - nodeid)[]) + nodeid).index(&FullRange)) }); let code = blocks::Code::from_node(node); @@ -615,8 +615,8 @@ pub fn pretty_print_input(sess: Session, // point to what was found, if there's an // accessible span. match ast_map.opt_span(nodeid) { - Some(sp) => sess.span_fatal(sp, message[]), - None => sess.fatal(message[]) + Some(sp) => sess.span_fatal(sp, message.index(&FullRange)), + None => sess.fatal(message.index(&FullRange)) } } } diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index b1e65dce6045a..3cacc1e232a8b 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -279,7 +279,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { pub fn t_param(&self, space: subst::ParamSpace, index: u32) -> Ty<'tcx> { let name = format!("T{}", index); - ty::mk_param(self.infcx.tcx, space, index, token::intern(name[])) + ty::mk_param(self.infcx.tcx, space, index, token::intern(name.index(&FullRange))) } pub fn re_early_bound(&self, diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 10788f9f7cb83..0a64404a7828e 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -221,14 +221,14 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { self.resolve_error(sp, format!("duplicate definition of {} `{}`", namespace_error_to_string(duplicate_type), - token::get_name(name))[]); + token::get_name(name)).index(&FullRange)); { let r = child.span_for_namespace(ns); for sp in r.iter() { self.session.span_note(*sp, format!("first definition of {} `{}` here", namespace_error_to_string(duplicate_type), - token::get_name(name))[]); + token::get_name(name)).index(&FullRange)); } } } @@ -1201,7 +1201,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { debug!("(building import directive) building import \ directive: {}::{}", self.names_to_string(module_.imports.borrow().last().unwrap() - .module_path[]), + .module_path.index(&FullRange)), token::get_name(target)); let mut import_resolutions = module_.import_resolutions diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 58102fe5629d9..d8c7a62e1948d 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1071,10 +1071,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("unresolved import `{}`{}", self.import_path_to_string( import_directive.module_path - [], + .index(&FullRange), import_directive.subclass), help); - self.resolve_error(span, msg[]); + self.resolve_error(span, msg.index(&FullRange)); } Indeterminate => break, // Bail out. We'll come around next time. Success(()) => () // Good. Continue. @@ -1104,7 +1104,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { .iter() .map(|seg| seg.identifier.name) .collect(); - self.names_to_string(names[]) + self.names_to_string(names.index(&FullRange)) } fn import_directive_subclass_to_string(&mut self, @@ -1168,7 +1168,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let module_path = &import_directive.module_path; debug!("(resolving import for module) resolving import `{}::...` in `{}`", - self.names_to_string(module_path[]), + self.names_to_string(module_path.index(&FullRange)), self.module_to_string(&*module_)); // First, resolve the module path for the directive, if necessary. @@ -1177,7 +1177,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some((self.graph_root.get_module(), LastMod(AllPublic))) } else { match self.resolve_module_path(module_.clone(), - module_path[], + module_path.index(&FullRange), DontUseLexicalScope, import_directive.span, ImportSearch) { @@ -1774,7 +1774,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ValueNS => "value", }, token::get_name(name).get()); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); } Some(_) | None => {} } @@ -1789,7 +1789,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if !name_bindings.defined_in_namespace_with(namespace, IMPORTABLE) { let msg = format!("`{}` is not directly importable", token::get_name(name)); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); } } @@ -1814,7 +1814,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { crate in this module \ (maybe you meant `use {0}::*`?)", token::get_name(name).get()); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); } Some(_) | None => {} } @@ -1836,7 +1836,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with value \ in this module", token::get_name(name).get()); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); if let Some(span) = value.value_span { self.session.span_note(span, "conflicting value here"); @@ -1854,7 +1854,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with type in \ this module", token::get_name(name).get()); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); if let Some(span) = ty.type_span { self.session.span_note(span, "note conflicting type here") @@ -1867,7 +1867,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("inherent implementations \ are only allowed on types \ defined in the current module"); - self.session.span_err(span, msg[]); + self.session.span_err(span, msg.index(&FullRange)); self.session.span_note(import_span, "import from other module here") } @@ -1876,7 +1876,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let msg = format!("import `{}` conflicts with existing \ submodule", token::get_name(name).get()); - self.session.span_err(import_span, msg[]); + self.session.span_err(import_span, msg.index(&FullRange)); if let Some(span) = ty.type_span { self.session.span_note(span, "note conflicting module here") @@ -1906,7 +1906,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { .span_err(span, format!("an external crate named `{}` has already \ been imported into this module", - token::get_name(name).get())[]); + token::get_name(name).get()).index(&FullRange)); } } @@ -1925,7 +1925,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("the name `{}` conflicts with an external \ crate that has been imported into this \ module", - token::get_name(name).get())[]); + token::get_name(name).get()).index(&FullRange)); } } @@ -1973,7 +1973,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let segment_name = token::get_name(name); let module_name = self.module_to_string(&*search_module); let mut span = span; - let msg = if "???" == module_name[] { + let msg = if "???" == module_name.index(&FullRange) { span.hi = span.lo + Pos::from_uint(segment_name.get().len()); match search_parent_externals(name, @@ -2086,14 +2086,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match module_prefix_result { Failed(None) => { let mpath = self.names_to_string(module_path); - let mpath = mpath[]; + let mpath = mpath.index(&FullRange); match mpath.rfind(':') { Some(idx) => { let msg = format!("Could not find `{}` in `{}`", // idx +- 1 to account for the // colons on either side - mpath[idx + 1..], - mpath[0..idx - 1]); + mpath.index(&((idx + 1)..)), + mpath.index(&(0..(idx - 1)))); return Failed(Some((span, msg))); }, None => { @@ -2268,7 +2268,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { true) { Failed(Some((span, msg))) => self.resolve_error(span, format!("failed to resolve. {}", - msg)[]), + msg).index(&FullRange)), Failed(None) => (), // Continue up the search chain. Indeterminate => { // We couldn't see through the higher scope because of an @@ -2528,7 +2528,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } else { let err = format!("unresolved import (maybe you meant `{}::*`?)", sn); - self.resolve_error((*imports)[index].span, err[]); + self.resolve_error((*imports)[index].span, err.index(&FullRange)); } } @@ -2620,7 +2620,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match def_like { DlDef(d @ DefUpvar(..)) => { self.session.span_bug(span, - format!("unexpected {} in bindings", d)[]) + format!("unexpected {} in bindings", d).index(&FullRange)) } DlDef(d @ DefLocal(_)) => { let node_id = d.def_id().node; @@ -2766,7 +2766,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (i, rib) in ribs.iter().enumerate().rev() { match rib.bindings.get(&name).cloned() { Some(def_like) => { - return self.upvarify(ribs[i + 1..], def_like, span); + return self.upvarify(ribs.index(&((i + 1)..)), def_like, span); } None => { // Continue. @@ -2859,7 +2859,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { generics, implemented_traits, &**self_type, - impl_items[]); + impl_items.index(&FullRange)); } ItemTrait(_, ref generics, ref bounds, ref trait_items) => { @@ -2937,7 +2937,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ItemStruct(ref struct_def, ref generics) => { self.resolve_struct(item.id, generics, - struct_def.fields[]); + struct_def.fields.index(&FullRange)); } ItemMod(ref module_) => { @@ -3010,7 +3010,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { parameter in this type \ parameter list", token::get_name( - name))[]) + name)).index(&FullRange)) } seen_bindings.insert(name); @@ -3182,7 +3182,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str); - self.resolve_error(trait_reference.path.span, msg[]); + self.resolve_error(trait_reference.path.span, msg.index(&FullRange)); } Some(def) => { match def { @@ -3194,14 +3194,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.resolve_error(trait_reference.path.span, format!("`{}` is not a trait", self.path_names_to_string( - &trait_reference.path))[]); + &trait_reference.path)).index(&FullRange)); // If it's a typedef, give a note if let DefTy(..) = def { self.session.span_note( trait_reference.path.span, format!("`type` aliases cannot be used for traits") - []); + .index(&FullRange)); } } } @@ -3398,7 +3398,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.resolve_error(span, format!("method `{}` is not a member of trait `{}`", token::get_name(name), - path_str)[]); + path_str).index(&FullRange)); } } } @@ -3467,7 +3467,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("variable `{}` from pattern #1 is \ not bound in pattern #{}", token::get_name(key), - i + 1)[]); + i + 1).index(&FullRange)); } Some(binding_i) => { if binding_0.binding_mode != binding_i.binding_mode { @@ -3476,7 +3476,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("variable `{}` is bound with different \ mode in pattern #{} than in pattern #1", token::get_name(key), - i + 1)[]); + i + 1).index(&FullRange)); } } } @@ -3489,7 +3489,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("variable `{}` from pattern {}{} is \ not bound in pattern {}1", token::get_name(key), - "#", i + 1, "#")[]); + "#", i + 1, "#").index(&FullRange)); } } } @@ -3604,7 +3604,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { let msg = format!("use of undeclared type name `{}`", self.path_names_to_string(path)); - self.resolve_error(ty.span, msg[]); + self.resolve_error(ty.span, msg.index(&FullRange)); } } } @@ -3676,7 +3676,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("declaration of `{}` shadows an enum \ variant or unit-like struct in \ scope", - token::get_name(renamed))[]); + token::get_name(renamed)).index(&FullRange)); } FoundConst(ref def, lp) if mode == RefutableMode => { debug!("(resolving pattern) resolving `{}` to \ @@ -3728,7 +3728,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { list", token::get_ident( ident)) - []) + .index(&FullRange)) } else if bindings_list.get(&renamed) == Some(&pat_id) { // Then this is a duplicate variable in the @@ -3737,7 +3737,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { format!("identifier `{}` is bound \ more than once in the same \ pattern", - token::get_ident(ident))[]); + token::get_ident(ident)).index(&FullRange)); } // Else, not bound in the same pattern: do // nothing. @@ -3763,13 +3763,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))[]); + path.segments.last().unwrap().identifier)).index(&FullRange)); } None => { self.resolve_error(path.span, format!("unresolved enum variant, struct or const `{}`", token::get_ident( - path.segments.last().unwrap().identifier))[]); + path.segments.last().unwrap().identifier)).index(&FullRange)); } } @@ -3800,7 +3800,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { def: {}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); - self.resolve_error(path.span, msg[]); + self.resolve_error(path.span, msg.index(&FullRange)); } } } @@ -3862,7 +3862,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match err { Some((span, msg)) => { self.resolve_error(span, format!("failed to resolve: {}", - msg)[]); + msg).index(&FullRange)); } None => () } @@ -4057,7 +4057,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let last_private; let module = self.current_module.clone(); match self.resolve_module_path(module, - module_path[], + module_path.index(&FullRange), UseLexicalScope, path.span, PathSearch) { @@ -4072,7 +4072,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { }; self.resolve_error(span, format!("failed to resolve. {}", - msg)[]); + msg).index(&FullRange)); return None; } Indeterminate => panic!("indeterminate unexpected"), @@ -4115,7 +4115,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let containing_module; let last_private; match self.resolve_module_path_from_root(root_module, - module_path[], + module_path.index(&FullRange), 0, path.span, PathSearch, @@ -4125,13 +4125,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some((span, msg)) => (span, msg), None => { let msg = format!("Use of undeclared module `::{}`", - self.names_to_string(module_path[])); + self.names_to_string(module_path.index(&FullRange))); (path.span, msg) } }; self.resolve_error(span, format!("failed to resolve. {}", - msg)[]); + msg).index(&FullRange)); return None; } @@ -4172,7 +4172,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } TypeNS => { let name = ident.name; - self.search_ribs(self.type_ribs[], name, span) + self.search_ribs(self.type_ribs.index(&FullRange), name, span) } }; @@ -4227,7 +4227,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match err { Some((span, msg)) => self.resolve_error(span, format!("failed to resolve. {}", - msg)[]), + msg).index(&FullRange)), None => () } @@ -4284,7 +4284,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } else { match this.resolve_module_path(root, - name_path[], + name_path.index(&FullRange), UseLexicalScope, span, PathSearch) { @@ -4322,7 +4322,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let name_path = path.segments.iter().map(|seg| seg.identifier.name).collect::>(); // Look for a method in the current self type's impl module. - match get_module(self, path.span, name_path[]) { + match get_module(self, path.span, name_path.index(&FullRange)) { Some(module) => match module.children.borrow().get(&name) { Some(binding) => { let p_str = self.path_names_to_string(&path); @@ -4533,7 +4533,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { def: {}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); - self.resolve_error(path.span, msg[]); + self.resolve_error(path.span, msg.index(&FullRange)); } } @@ -4594,7 +4594,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.resolve_error( expr.span, format!("use of undeclared label `{}`", - token::get_ident(label))[]) + token::get_ident(label)).index(&FullRange)) } Some(DlDef(def @ DefLabel(_))) => { // Since this def is a label, it is never read. @@ -4733,7 +4733,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { then {}", node_id, *entry.get(), - def)[]); + def).index(&FullRange)); }, Vacant(entry) => { entry.insert(def); }, } @@ -4749,7 +4749,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.resolve_error(pat.span, format!("cannot use `ref` binding mode \ with {}", - descr)[]); + descr).index(&FullRange)); } } } @@ -4785,7 +4785,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { return "???".to_string(); } self.names_to_string(names.into_iter().rev() - .collect::>()[]) + .collect::>().index(&FullRange)) } #[allow(dead_code)] // useful for debugging diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 8fbeadc55b387..388bc4a4d30d9 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -128,7 +128,7 @@ pub fn find_crate_name(sess: Option<&Session>, attrs: &[ast::Attribute], input: &Input) -> String { let validate = |&: s: String, span: Option| { - creader::validate_crate_name(sess, s[], span); + creader::validate_crate_name(sess, s.index(&FullRange), span); s }; @@ -146,7 +146,7 @@ pub fn find_crate_name(sess: Option<&Session>, let msg = format!("--crate-name and #[crate_name] are \ required to match, but `{}` != `{}`", s, name); - sess.span_err(attr.span, msg[]); + sess.span_err(attr.span, msg.index(&FullRange)); } } return validate(s.clone(), None); @@ -192,17 +192,17 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>, // to be independent of one another in the crate. symbol_hasher.reset(); - symbol_hasher.input_str(link_meta.crate_name[]); + symbol_hasher.input_str(link_meta.crate_name.index(&FullRange)); symbol_hasher.input_str("-"); symbol_hasher.input_str(link_meta.crate_hash.as_str()); for meta in tcx.sess.crate_metadata.borrow().iter() { - symbol_hasher.input_str(meta[]); + symbol_hasher.input_str(meta.index(&FullRange)); } symbol_hasher.input_str("-"); - symbol_hasher.input_str(encoder::encoded_ty(tcx, t)[]); + symbol_hasher.input_str(encoder::encoded_ty(tcx, t).index(&FullRange)); // Prefix with 'h' so that it never blends into adjacent digits let mut hash = String::from_str("h"); - hash.push_str(truncated_hash_result(symbol_hasher)[]); + hash.push_str(truncated_hash_result(symbol_hasher).index(&FullRange)); hash } @@ -251,7 +251,7 @@ pub fn sanitize(s: &str) -> String { let mut tstr = String::new(); for c in c.escape_unicode() { tstr.push(c) } result.push('$'); - result.push_str(tstr[1..]); + result.push_str(tstr.index(&(1..))); } } } @@ -260,7 +260,7 @@ pub fn sanitize(s: &str) -> String { if result.len() > 0u && result.as_bytes()[0] != '_' as u8 && ! (result.as_bytes()[0] as char).is_xid_start() { - return format!("_{}", result[]); + return format!("_{}", result.index(&FullRange)); } return result; @@ -286,12 +286,12 @@ pub fn mangle>(mut path: PI, fn push(n: &mut String, s: &str) { let sani = sanitize(s); - n.push_str(format!("{}{}", sani.len(), sani)[]); + n.push_str(format!("{}{}", sani.len(), sani).index(&FullRange)); } // First, connect each component with pairs. for e in path { - push(&mut n, token::get_name(e.name()).get()[]) + push(&mut n, token::get_name(e.name()).get().index(&FullRange)) } match hash { @@ -329,17 +329,17 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl hash.push(EXTRA_CHARS.as_bytes()[extra2] as char); hash.push(EXTRA_CHARS.as_bytes()[extra3] as char); - exported_name(path, hash[]) + exported_name(path, hash.index(&FullRange)) } pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, name: &str) -> String { let s = ppaux::ty_to_string(ccx.tcx(), t); - let path = [PathName(token::intern(s[])), + let path = [PathName(token::intern(s.index(&FullRange))), gensym_name(name)]; let hash = get_symbol_hash(ccx, t); - mangle(ast_map::Values(path.iter()), Some(hash[])) + mangle(ast_map::Values(path.iter()), Some(hash.index(&FullRange))) } pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String { @@ -359,7 +359,7 @@ pub fn remove(sess: &Session, path: &Path) { Err(e) => { sess.err(format!("failed to remove {}: {}", path.display(), - e)[]); + e).index(&FullRange)); } } } @@ -374,7 +374,7 @@ pub fn link_binary(sess: &Session, for &crate_type in sess.crate_types.borrow().iter() { if invalid_output_for_target(sess, crate_type) { sess.bug(format!("invalid output type `{}` for target os `{}`", - crate_type, sess.opts.target_triple)[]); + crate_type, sess.opts.target_triple).index(&FullRange)); } let out_file = link_binary_output(sess, trans, crate_type, outputs, crate_name); @@ -439,8 +439,8 @@ pub fn filename_for_input(sess: &Session, out_filename.with_filename(format!("lib{}.rlib", libname)) } config::CrateTypeDylib => { - let (prefix, suffix) = (sess.target.target.options.dll_prefix[], - sess.target.target.options.dll_suffix[]); + let (prefix, suffix) = (sess.target.target.options.dll_prefix.index(&FullRange), + sess.target.target.options.dll_suffix.index(&FullRange)); out_filename.with_filename(format!("{}{}{}", prefix, libname, @@ -450,7 +450,7 @@ pub fn filename_for_input(sess: &Session, out_filename.with_filename(format!("lib{}.a", libname)) } config::CrateTypeExecutable => { - let suffix = sess.target.target.options.exe_suffix[]; + let suffix = sess.target.target.options.exe_suffix.index(&FullRange); out_filename.with_filename(format!("{}{}", libname, suffix)) } } @@ -479,12 +479,12 @@ fn link_binary_output(sess: &Session, if !out_is_writeable { sess.fatal(format!("output file {} is not writeable -- check its \ permissions.", - out_filename.display())[]); + out_filename.display()).index(&FullRange)); } else if !obj_is_writeable { sess.fatal(format!("object file {} is not writeable -- check its \ permissions.", - obj_filename.display())[]); + obj_filename.display()).index(&FullRange)); } match crate_type { @@ -539,7 +539,7 @@ fn link_rlib<'a>(sess: &'a Session, for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { match kind { cstore::NativeStatic => { - ab.add_native_library(l[]).unwrap(); + ab.add_native_library(l.index(&FullRange)).unwrap(); } cstore::NativeFramework | cstore::NativeUnknown => {} } @@ -587,12 +587,12 @@ fn link_rlib<'a>(sess: &'a Session, let tmpdir = TempDir::new("rustc").ok().expect("needs a temp dir"); let metadata = tmpdir.path().join(METADATA_FILENAME); match fs::File::create(&metadata).write(trans.metadata - []) { + .index(&FullRange)) { Ok(..) => {} Err(e) => { sess.err(format!("failed to write {}: {}", metadata.display(), - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); } } @@ -608,27 +608,27 @@ 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)[]); + let bc_filename = obj_filename.with_extension(format!("{}.bc", i).index(&FullRange)); let bc_deflated_filename = obj_filename.with_extension( - format!("{}.bytecode.deflate", i)[]); + format!("{}.bytecode.deflate", i).index(&FullRange)); let bc_data = match fs::File::open(&bc_filename).read_to_end() { Ok(buffer) => buffer, Err(e) => sess.fatal(format!("failed to read bytecode: {}", - e)[]) + e).index(&FullRange)) }; - let bc_data_deflated = match flate::deflate_bytes(bc_data[]) { + let bc_data_deflated = match flate::deflate_bytes(bc_data.index(&FullRange)) { Some(compressed) => compressed, None => sess.fatal(format!("failed to compress bytecode from {}", - bc_filename.display())[]) + bc_filename.display()).index(&FullRange)) }; let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) { Ok(file) => file, Err(e) => { sess.fatal(format!("failed to create compressed bytecode \ - file: {}", e)[]) + file: {}", e).index(&FullRange)) } }; @@ -637,7 +637,7 @@ fn link_rlib<'a>(sess: &'a Session, Ok(()) => {} Err(e) => { sess.err(format!("failed to write compressed bytecode: \ - {}", e)[]); + {}", e).index(&FullRange)); sess.abort_if_errors() } }; @@ -677,7 +677,7 @@ fn write_rlib_bytecode_object_v1(writer: &mut T, try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) }; try! { writer.write_le_u32(1) }; try! { writer.write_le_u64(bc_data_deflated_size) }; - try! { writer.write(bc_data_deflated[]) }; + try! { writer.write(bc_data_deflated.index(&FullRange)) }; let number_of_bytes_written_so_far = RLIB_BYTECODE_OBJECT_MAGIC.len() + // magic id @@ -728,11 +728,11 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { let p = match *path { Some(ref p) => p.clone(), None => { sess.err(format!("could not find rlib for: `{}`", - name)[]); + name).index(&FullRange)); continue } }; - ab.add_rlib(&p, name[], sess.lto()).unwrap(); + ab.add_rlib(&p, name.index(&FullRange), sess.lto()).unwrap(); let native_libs = csearch::get_native_libraries(&sess.cstore, cnum); all_native_libs.extend(native_libs.into_iter()); @@ -754,7 +754,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { cstore::NativeUnknown => "library", cstore::NativeFramework => "framework", }; - sess.note(format!("{}: {}", name, *lib)[]); + sess.note(format!("{}: {}", name, *lib).index(&FullRange)); } } @@ -768,12 +768,12 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, // The invocations of cc share some flags across platforms let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname[]); + let mut cmd = Command::new(pname.index(&FullRange)); - cmd.args(sess.target.target.options.pre_link_args[]); + cmd.args(sess.target.target.options.pre_link_args.index(&FullRange)); link_args(&mut cmd, sess, dylib, tmpdir.path(), trans, obj_filename, out_filename); - cmd.args(sess.target.target.options.post_link_args[]); + cmd.args(sess.target.target.options.post_link_args.index(&FullRange)); if !sess.target.target.options.no_compiler_rt { cmd.arg("-lcompiler-rt"); } @@ -793,11 +793,11 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, if !prog.status.success() { sess.err(format!("linking with `{}` failed: {}", pname, - prog.status)[]); - sess.note(format!("{}", &cmd)[]); + prog.status).index(&FullRange)); + sess.note(format!("{}", &cmd).index(&FullRange)); let mut output = prog.error.clone(); - output.push_all(prog.output[]); - sess.note(str::from_utf8(output[]).unwrap()); + output.push_all(prog.output.index(&FullRange)); + sess.note(str::from_utf8(output.index(&FullRange)).unwrap()); sess.abort_if_errors(); } debug!("linker stderr:\n{}", String::from_utf8(prog.error).unwrap()); @@ -806,7 +806,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, Err(e) => { sess.err(format!("could not exec the linker `{}`: {}", pname, - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); } } @@ -818,7 +818,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, match Command::new("dsymutil").arg(out_filename).output() { Ok(..) => {} Err(e) => { - sess.err(format!("failed to run dsymutil: {}", e)[]); + sess.err(format!("failed to run dsymutil: {}", e).index(&FullRange)); sess.abort_if_errors(); } } @@ -867,7 +867,7 @@ fn link_args(cmd: &mut Command, let mut v = b"-Wl,-force_load,".to_vec(); v.push_all(morestack.as_vec()); - cmd.arg(v[]); + cmd.arg(v.index(&FullRange)); } else { cmd.args(&["-Wl,--whole-archive", "-lmorestack", "-Wl,--no-whole-archive"]); } @@ -992,7 +992,7 @@ fn link_args(cmd: &mut Command, if sess.opts.cg.rpath { let mut v = "-Wl,-install_name,@rpath/".as_bytes().to_vec(); v.push_all(out_filename.filename().unwrap()); - cmd.arg(v[]); + cmd.arg(v.index(&FullRange)); } } else { cmd.arg("-shared"); @@ -1004,7 +1004,7 @@ fn link_args(cmd: &mut Command, // addl_lib_search_paths if sess.opts.cg.rpath { let sysroot = sess.sysroot(); - let target_triple = sess.opts.target_triple[]; + let target_triple = sess.opts.target_triple.index(&FullRange); let get_install_prefix_lib_path = |:| { let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX"); let tlib = filesearch::relative_target_lib_path(sysroot, target_triple); @@ -1021,14 +1021,14 @@ fn link_args(cmd: &mut Command, get_install_prefix_lib_path: get_install_prefix_lib_path, realpath: ::util::fs::realpath }; - cmd.args(rpath::get_rpath_flags(rpath_config)[]); + cmd.args(rpath::get_rpath_flags(rpath_config).index(&FullRange)); } // Finally add all the linker arguments provided on the command line along // with any #[link_args] attributes found inside the crate let empty = Vec::new(); - cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty)[]); - cmd.args(used_link_args[]); + cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty).index(&FullRange)); + cmd.args(used_link_args.index(&FullRange)); } // # Native library linking @@ -1082,14 +1082,14 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) { } else { // -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[], - sess.target.target.options.staticlib_prefix[], - sess.target.target.options.staticlib_suffix[], - search_path[], + let lib = archive::find_library(l.index(&FullRange), + sess.target.target.options.staticlib_prefix.index(&FullRange), + sess.target.target.options.staticlib_suffix.index(&FullRange), + search_path.index(&FullRange), &sess.diagnostic().handler); let mut v = b"-Wl,-force_load,".to_vec(); v.push_all(lib.as_vec()); - cmd.arg(v[]); + cmd.arg(v.index(&FullRange)); } } if takes_hints { @@ -1102,7 +1102,7 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) { cmd.arg(format!("-l{}", l)); } cstore::NativeFramework => { - cmd.arg("-framework").arg(l[]); + cmd.arg("-framework").arg(l.index(&FullRange)); } cstore::NativeStatic => unreachable!(), } @@ -1158,7 +1158,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // Converts a library file-stem into a cc -l argument fn unlib<'a>(config: &config::Config, stem: &'a [u8]) -> &'a [u8] { if stem.starts_with("lib".as_bytes()) && !config.target.options.is_like_windows { - stem[3..] + stem.index(&(3..)) } else { stem } @@ -1183,9 +1183,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // against the archive. if sess.lto() { let name = cratepath.filename_str().unwrap(); - let name = name[3..name.len() - 5]; // chop off lib/.rlib + let name = name.index(&(3..(name.len() - 5))); // chop off lib/.rlib time(sess.time_passes(), - format!("altering {}.rlib", name)[], + format!("altering {}.rlib", name).index(&FullRange), (), |()| { let dst = tmpdir.join(cratepath.filename().unwrap()); match fs::copy(&cratepath, &dst) { @@ -1194,7 +1194,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, sess.err(format!("failed to copy {} to {}: {}", cratepath.display(), dst.display(), - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); } } @@ -1206,7 +1206,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, Err(e) => { sess.err(format!("failed to chmod {} when preparing \ for LTO: {}", dst.display(), - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); } } @@ -1220,9 +1220,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, maybe_ar_prog: sess.opts.cg.ar.clone() }; let mut archive = Archive::open(config); - archive.remove_file(format!("{}.o", name)[]); + archive.remove_file(format!("{}.o", name).index(&FullRange)); let files = archive.files(); - if files.iter().any(|s| s[].ends_with(".o")) { + if files.iter().any(|s| s.index(&FullRange).ends_with(".o")) { cmd.arg(dst); } }); @@ -1244,7 +1244,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, let mut v = "-l".as_bytes().to_vec(); v.push_all(unlib(&sess.target, cratepath.filestem().unwrap())); - cmd.arg(v[]); + cmd.arg(v.index(&FullRange)); } } @@ -1286,7 +1286,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) { } cstore::NativeFramework => { cmd.arg("-framework"); - cmd.arg(lib[]); + cmd.arg(lib.index(&FullRange)); } cstore::NativeStatic => { sess.bug("statics shouldn't be propagated"); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index f3e90c43a8414..450b4176b7abe 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -54,21 +54,21 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, Some(p) => p, None => { sess.fatal(format!("could not find rlib for: `{}`", - name)[]); + name).index(&FullRange)); } }; let archive = ArchiveRO::open(&path).expect("wanted an rlib"); let file = path.filename_str().unwrap(); - let file = file[3..file.len() - 5]; // chop off lib/.rlib + let file = file.index(&(3..(file.len() - 5))); // chop off lib/.rlib debug!("reading {}", file); for i in iter::count(0u, 1) { let bc_encoded = time(sess.time_passes(), - format!("check for {}.{}.bytecode.deflate", name, i)[], + format!("check for {}.{}.bytecode.deflate", name, i).index(&FullRange), (), |_| { archive.read(format!("{}.{}.bytecode.deflate", - file, i)[]) + file, i).index(&FullRange)) }); let bc_encoded = match bc_encoded { Some(data) => data, @@ -76,7 +76,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, if i == 0 { // No bitcode was found at all. sess.fatal(format!("missing compressed bytecode in {}", - path.display())[]); + path.display()).index(&FullRange)); } // No more bitcode files to read. break; @@ -91,20 +91,20 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, if version == 1 { // The only version existing so far let data_size = extract_compressed_bytecode_size_v1(bc_encoded); - let compressed_data = bc_encoded[ + let compressed_data = bc_encoded.index(&( link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET.. - link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint]; + (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint))); match flate::inflate_bytes(compressed_data) { Some(inflated) => inflated, None => { sess.fatal(format!("failed to decompress bc of `{}`", - name)[]) + name).index(&FullRange)) } } } else { sess.fatal(format!("Unsupported bytecode format version {}", - version)[]) + version).index(&FullRange)) } }) } else { @@ -115,7 +115,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, Some(bc) => bc, None => { sess.fatal(format!("failed to decompress bc of `{}`", - name)[]) + name).index(&FullRange)) } } }) @@ -124,7 +124,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let ptr = bc_decoded.as_slice().as_ptr(); debug!("linking {}, part {}", name, i); time(sess.time_passes(), - format!("ll link {}.{}", name, i)[], + format!("ll link {}.{}", name, i).index(&FullRange), (), |()| unsafe { if !llvm::LLVMRustLinkInExternalBitcode(llmod, @@ -132,7 +132,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, bc_decoded.len() as libc::size_t) { write::llvm_err(sess.diagnostic().handler(), format!("failed to load bc of `{}`", - name[])); + name.index(&FullRange))); } }); } @@ -186,7 +186,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, fn is_versioned_bytecode_format(bc: &[u8]) -> bool { let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len(); return bc.len() > magic_id_byte_count && - bc[..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC; + bc.index(&(0..magic_id_byte_count)) == link::RLIB_BYTECODE_OBJECT_MAGIC; } fn extract_bytecode_format_version(bc: &[u8]) -> u32 { @@ -198,8 +198,8 @@ fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 { } fn read_from_le_bytes(bytes: &[u8], position_in_bytes: uint) -> T { - let byte_data = bytes[position_in_bytes.. - position_in_bytes + mem::size_of::()]; + let byte_data = bytes.index(&(position_in_bytes.. + (position_in_bytes + mem::size_of::()))); let data = unsafe { *(byte_data.as_ptr() as *const T) }; diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 98e2b4b9dddb5..f27f7dc571937 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -47,14 +47,14 @@ pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! { unsafe { let cstr = llvm::LLVMRustGetLastError(); if cstr == ptr::null() { - handler.fatal(msg[]); + handler.fatal(msg.index(&FullRange)); } else { let err = ffi::c_str_to_bytes(&cstr); let err = String::from_utf8_lossy(err.as_slice()).to_string(); libc::free(cstr as *mut _); handler.fatal(format!("{}: {}", - msg[], - err[])[]); + msg.index(&FullRange), + err.index(&FullRange)).index(&FullRange)); } } } @@ -104,13 +104,13 @@ impl SharedEmitter { match diag.code { Some(ref code) => { handler.emit_with_code(None, - diag.msg[], - code[], + diag.msg.index(&FullRange), + code.index(&FullRange), diag.lvl); }, None => { handler.emit(None, - diag.msg[], + diag.msg.index(&FullRange), diag.lvl); }, } @@ -165,8 +165,8 @@ fn get_llvm_opt_level(optimize: config::OptLevel) -> llvm::CodeGenOptLevel { fn create_target_machine(sess: &Session) -> TargetMachineRef { let reloc_model_arg = match sess.opts.cg.relocation_model { - Some(ref s) => s[], - None => sess.target.target.options.relocation_model[] + Some(ref s) => s.index(&FullRange), + None => sess.target.target.options.relocation_model.index(&FullRange) }; let reloc_model = match reloc_model_arg { "pic" => llvm::RelocPIC, @@ -177,7 +177,7 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { sess.err(format!("{} is not a valid relocation mode", sess.opts .cg - .relocation_model)[]); + .relocation_model).index(&FullRange)); sess.abort_if_errors(); unreachable!(); } @@ -198,8 +198,8 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { let fdata_sections = ffunction_sections; let code_model_arg = match sess.opts.cg.code_model { - Some(ref s) => s[], - None => sess.target.target.options.code_model[] + Some(ref s) => s.index(&FullRange), + None => sess.target.target.options.code_model.index(&FullRange) }; let code_model = match code_model_arg { @@ -212,13 +212,13 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { sess.err(format!("{} is not a valid code model", sess.opts .cg - .code_model)[]); + .code_model).index(&FullRange)); sess.abort_if_errors(); unreachable!(); } }; - let triple = sess.target.target.llvm_target[]; + let triple = sess.target.target.llvm_target.index(&FullRange); let tm = unsafe { let triple = CString::from_slice(triple.as_bytes()); @@ -350,13 +350,13 @@ unsafe extern "C" fn inline_asm_handler(diag: SMDiagnosticRef, match cgcx.lto_ctxt { Some((sess, _)) => { sess.codemap().with_expn_info(ExpnId::from_llvm_cookie(cookie), |info| match info { - Some(ei) => sess.span_err(ei.call_site, msg[]), - None => sess.err(msg[]), + Some(ei) => sess.span_err(ei.call_site, msg.index(&FullRange)), + None => sess.err(msg.index(&FullRange)), }); } None => { - cgcx.handler.err(msg[]); + cgcx.handler.err(msg.index(&FullRange)); cgcx.handler.note("build without -C codegen-units for more exact errors"); } } @@ -381,8 +381,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[] }, - llvm::twine_to_string(opt.message))[]); + if loc.is_empty() { "[unknown]" } else { loc.index(&FullRange) }, + llvm::twine_to_string(opt.message)).index(&FullRange)); } } @@ -518,14 +518,14 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext, } if config.emit_asm { - let path = output_names.with_extension(format!("{}.s", name_extra)[]); + let path = output_names.with_extension(format!("{}.s", name_extra).index(&FullRange)); with_codegen(tm, llmod, config.no_builtins, |cpm| { write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFileType); }); } if config.emit_obj { - let path = output_names.with_extension(format!("{}.o", name_extra)[]); + let path = output_names.with_extension(format!("{}.o", name_extra).index(&FullRange)); with_codegen(tm, llmod, config.no_builtins, |cpm| { write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFileType); }); @@ -639,7 +639,7 @@ pub fn run_passes(sess: &Session, // Process the work items, optionally using worker threads. if sess.opts.cg.codegen_units == 1 { - run_work_singlethreaded(sess, trans.reachable[], work_items); + run_work_singlethreaded(sess, trans.reachable.index(&FullRange), work_items); } else { run_work_multithreaded(sess, work_items, sess.opts.cg.codegen_units); } @@ -667,7 +667,7 @@ pub fn run_passes(sess: &Session, // 2) Multiple codegen units, with `-o some_name`. We have // no good solution for this case, so warn the user. sess.warn(format!("ignoring -o because multiple .{} files were produced", - ext)[]); + ext).index(&FullRange)); } else { // 3) Multiple codegen units, but no `-o some_name`. We // just leave the `foo.0.x` files in place. @@ -700,20 +700,20 @@ pub fn run_passes(sess: &Session, }; let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname[]); + let mut cmd = Command::new(pname.index(&FullRange)); - cmd.args(sess.target.target.options.pre_link_args[]); + cmd.args(sess.target.target.options.pre_link_args.index(&FullRange)); cmd.arg("-nostdlib"); for index in range(0, trans.modules.len()) { - cmd.arg(crate_output.with_extension(format!("{}.o", index)[])); + cmd.arg(crate_output.with_extension(format!("{}.o", index).index(&FullRange))); } cmd.arg("-r") .arg("-o") .arg(windows_output_path.as_ref().unwrap_or(output_path)); - cmd.args(sess.target.target.options.post_link_args[]); + cmd.args(sess.target.target.options.post_link_args.index(&FullRange)); if (sess.opts.debugging_opts & config::PRINT_LINK_ARGS) != 0 { println!("{}", &cmd); @@ -726,14 +726,14 @@ pub fn run_passes(sess: &Session, Ok(status) => { if !status.success() { sess.err(format!("linking of {} with `{}` failed", - output_path.display(), cmd)[]); + output_path.display(), cmd).index(&FullRange)); sess.abort_if_errors(); } }, Err(e) => { sess.err(format!("could not exec the linker `{}`: {}", pname, - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); }, } @@ -818,12 +818,12 @@ pub fn run_passes(sess: &Session, for i in range(0, trans.modules.len()) { if modules_config.emit_obj { let ext = format!("{}.o", i); - remove(sess, &crate_output.with_extension(ext[])); + remove(sess, &crate_output.with_extension(ext.index(&FullRange))); } if modules_config.emit_bc && !keep_numbered_bitcode { let ext = format!("{}.bc", i); - remove(sess, &crate_output.with_extension(ext[])); + remove(sess, &crate_output.with_extension(ext.index(&FullRange))); } } @@ -949,7 +949,7 @@ fn run_work_multithreaded(sess: &Session, pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) { let pname = get_cc_prog(sess); - let mut cmd = Command::new(pname[]); + let mut cmd = Command::new(pname.index(&FullRange)); cmd.arg("-c").arg("-o").arg(outputs.path(config::OutputTypeObject)) .arg(outputs.temp_path(config::OutputTypeAssembly)); @@ -960,18 +960,18 @@ pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) { if !prog.status.success() { sess.err(format!("linking with `{}` failed: {}", pname, - prog.status)[]); - sess.note(format!("{}", &cmd)[]); + prog.status).index(&FullRange)); + sess.note(format!("{}", &cmd).index(&FullRange)); let mut note = prog.error.clone(); - note.push_all(prog.output[]); - sess.note(str::from_utf8(note[]).unwrap()); + note.push_all(prog.output.index(&FullRange)); + sess.note(str::from_utf8(note.index(&FullRange)).unwrap()); sess.abort_if_errors(); } }, Err(e) => { sess.err(format!("could not exec the linker `{}`: {}", pname, - e)[]); + e).index(&FullRange)); sess.abort_if_errors(); } } @@ -1004,7 +1004,7 @@ unsafe fn configure_llvm(sess: &Session) { if sess.print_llvm_passes() { add("-debug-pass=Structure"); } for arg in sess.opts.cg.llvm_args.iter() { - add((*arg)[]); + add((*arg).index(&FullRange)); } } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 8e6276b61f949..b27421ea42661 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -94,7 +94,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // dump info about all the external crates referenced from this crate self.sess.cstore.iter_crate_data(|n, cmd| { - self.fmt.external_crate_str(krate.span, cmd.name[], n); + self.fmt.external_crate_str(krate.span, cmd.name.index(&FullRange), n); }); self.fmt.recorder.record("end_external_crates\n"); } @@ -143,7 +143,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname[], + qualname.index(&FullRange), self.cur_scope); } } @@ -161,7 +161,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname[], + qualname.index(&FullRange), self.cur_scope); } } @@ -180,17 +180,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { let (ref span, ref qualname) = sub_paths[len-2]; self.fmt.sub_type_ref_str(path.span, *span, - qualname[]); + qualname.index(&FullRange)); // write the other sub-paths if len <= 2 { return; } - let sub_paths = sub_paths[..len-2]; + let sub_paths = sub_paths.index(&(0..(len-2))); for &(ref span, ref qualname) in sub_paths.iter() { self.fmt.sub_mod_ref_str(path.span, *span, - qualname[], + qualname.index(&FullRange), self.cur_scope); } } @@ -199,7 +199,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { fn lookup_type_ref(&self, ref_id: NodeId) -> Option { if !self.analysis.ty_cx.def_map.borrow().contains_key(&ref_id) { self.sess.bug(format!("def_map has no key for {} in lookup_type_ref", - ref_id)[]); + ref_id).index(&FullRange)); } let def = (*self.analysis.ty_cx.def_map.borrow())[ref_id]; match def { @@ -212,7 +212,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { let def_map = self.analysis.ty_cx.def_map.borrow(); if !def_map.contains_key(&ref_id) { self.sess.span_bug(span, format!("def_map has no key for {} in lookup_def_kind", - ref_id)[]); + ref_id).index(&FullRange)); } let def = (*def_map)[ref_id]; match def { @@ -241,7 +241,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { def::DefMethod(..) | def::DefPrimTy(_) => { self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {}", - def)[]); + def).index(&FullRange)); }, } } @@ -262,8 +262,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { span_utils.span_for_last_ident(p.span), id, qualname, - path_to_string(p)[], - typ[]); + path_to_string(p).index(&FullRange), + typ.index(&FullRange)); } self.collected_paths.clear(); } @@ -285,14 +285,14 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { match item.node { ast::ItemImpl(_, _, _, _, ref ty, _) => { let mut result = String::from_str("<"); - result.push_str(ty_to_string(&**ty)[]); + result.push_str(ty_to_string(&**ty).index(&FullRange)); match ty::trait_of_item(&self.analysis.ty_cx, ast_util::local_def(method.id)) { Some(def_id) => { result.push_str(" as "); result.push_str( - ty::item_path_str(&self.analysis.ty_cx, def_id)[]); + ty::item_path_str(&self.analysis.ty_cx, def_id).index(&FullRange)); }, None => {} } @@ -302,7 +302,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { _ => { self.sess.span_bug(method.span, format!("Container {} for method {} not an impl?", - impl_id.node, method.id)[]); + impl_id.node, method.id).index(&FullRange)); }, } }, @@ -312,7 +312,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { impl_id.node, method.id, self.analysis.ty_cx.map.get(impl_id.node) - )[]); + ).index(&FullRange)); }, }, None => match ty::trait_of_item(&self.analysis.ty_cx, @@ -328,20 +328,20 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { _ => { self.sess.span_bug(method.span, format!("Could not find container {} for method {}", - def_id.node, method.id)[]); + def_id.node, method.id).index(&FullRange)); } } }, None => { self.sess.span_bug(method.span, format!("Could not find container for method {}", - method.id)[]); + method.id).index(&FullRange)); }, }, }; qualname.push_str(get_ident(method.pe_ident()).get()); - let qualname = qualname[]; + let qualname = qualname.index(&FullRange); // record the decl for this def (if it has one) let decl_id = ty::trait_item_of_item(&self.analysis.ty_cx, @@ -430,13 +430,13 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { Some(sub_span) => self.fmt.field_str(field.span, Some(sub_span), field.node.id, - name.get()[], - qualname[], - typ[], + name.get().index(&FullRange), + qualname.index(&FullRange), + typ.index(&FullRange), scope_id), None => self.sess.span_bug(field.span, format!("Could not find sub-span for field {}", - qualname)[]), + qualname).index(&FullRange)), } }, _ => (), @@ -463,7 +463,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.typedef_str(full_span, Some(*param_ss), param.id, - name[], + name.index(&FullRange), ""); } self.visit_generics(generics); @@ -480,10 +480,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.fn_str(item.span, sub_span, item.id, - qualname[], + qualname.index(&FullRange), self.cur_scope); - self.process_formals(&decl.inputs, qualname[]); + self.process_formals(&decl.inputs, qualname.index(&FullRange)); // walk arg and return types for arg in decl.inputs.iter() { @@ -497,7 +497,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // walk the body self.nest(item.id, |v| v.visit_block(&*body)); - self.process_generic_params(ty_params, item.span, qualname[], item.id); + self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id); } fn process_static(&mut self, @@ -519,9 +519,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, get_ident(item.ident).get(), - qualname[], - value[], - ty_to_string(&*typ)[], + qualname.index(&FullRange), + value.index(&FullRange), + ty_to_string(&*typ).index(&FullRange), self.cur_scope); // walk type and init value @@ -542,9 +542,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, get_ident(item.ident).get(), - qualname[], + qualname.index(&FullRange), "", - ty_to_string(&*typ)[], + ty_to_string(&*typ).index(&FullRange), self.cur_scope); // walk type and init value @@ -568,17 +568,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { sub_span, item.id, ctor_id, - qualname[], + qualname.index(&FullRange), self.cur_scope, - val[]); + val.index(&FullRange)); // fields for field in def.fields.iter() { - self.process_struct_field_def(field, qualname[], item.id); + self.process_struct_field_def(field, qualname.index(&FullRange), item.id); self.visit_ty(&*field.node.ty); } - self.process_generic_params(ty_params, item.span, qualname[], item.id); + self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id); } fn process_enum(&mut self, @@ -591,12 +591,12 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { Some(sub_span) => self.fmt.enum_str(item.span, Some(sub_span), item.id, - enum_name[], + enum_name.index(&FullRange), self.cur_scope, - val[]), + val.index(&FullRange)), None => self.sess.span_bug(item.span, format!("Could not find subspan for enum {}", - enum_name)[]), + enum_name).index(&FullRange)), } for variant in enum_definition.variants.iter() { let name = get_ident(variant.node.name); @@ -612,9 +612,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.span_for_first_ident(variant.span), variant.node.id, name, - qualname[], - enum_name[], - val[], + qualname.index(&FullRange), + enum_name.index(&FullRange), + val.index(&FullRange), item.id); for arg in args.iter() { self.visit_ty(&*arg.ty); @@ -630,20 +630,20 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.span_for_first_ident(variant.span), variant.node.id, ctor_id, - qualname[], - enum_name[], - val[], + qualname.index(&FullRange), + enum_name.index(&FullRange), + val.index(&FullRange), item.id); for field in struct_def.fields.iter() { - self.process_struct_field_def(field, qualname[], variant.node.id); + self.process_struct_field_def(field, qualname.index(&FullRange), variant.node.id); self.visit_ty(&*field.node.ty); } } } } - self.process_generic_params(ty_params, item.span, enum_name[], item.id); + self.process_generic_params(ty_params, item.span, enum_name.index(&FullRange), item.id); } fn process_impl(&mut self, @@ -703,9 +703,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.trait_str(item.span, sub_span, item.id, - qualname[], + qualname.index(&FullRange), self.cur_scope, - val[]); + val.index(&FullRange)); // super-traits for super_bound in trait_refs.iter() { @@ -737,7 +737,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } // walk generics and methods - self.process_generic_params(generics, item.span, qualname[], item.id); + self.process_generic_params(generics, item.span, qualname.index(&FullRange), item.id); for method in methods.iter() { self.visit_trait_item(method) } @@ -755,9 +755,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.fmt.mod_str(item.span, sub_span, item.id, - qualname[], + qualname.index(&FullRange), self.cur_scope, - filename[]); + filename.index(&FullRange)); self.nest(item.id, |v| visit::walk_mod(v, m)); } @@ -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)[]); + format!("def_map has no key for {} in visit_expr", id).index(&FullRange)); } let def = &(*def_map)[id]; let sub_span = self.span.span_for_last_ident(span); @@ -841,7 +841,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.cur_scope), _ => self.sess.span_bug(span, format!("Unexpected def kind while looking up path in '{}'", - self.span.snippet(span))[]), + self.span.snippet(span)).index(&FullRange)), } // modules or types in the path prefix match *def { @@ -959,7 +959,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.cur_scope); // walk receiver and args - visit::walk_exprs(self, args[]); + visit::walk_exprs(self, args.index(&FullRange)); } fn process_pat(&mut self, p:&ast::Pat) { @@ -976,7 +976,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { None => { self.sess.span_bug(p.span, format!("Could not find struct_def for `{}`", - self.span.snippet(p.span))[]); + self.span.snippet(p.span)).index(&FullRange)); } }; for &Spanned { node: ref field, span } in fields.iter() { @@ -1061,11 +1061,11 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.typedef_str(item.span, sub_span, item.id, - qualname[], - value[]); + qualname.index(&FullRange), + value.index(&FullRange)); self.visit_ty(&**ty); - self.process_generic_params(ty_params, item.span, qualname[], item.id); + self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id); }, ast::ItemMac(_) => (), _ => visit::walk_item(self, item), @@ -1122,12 +1122,12 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { None => { self.sess.span_bug(method_type.span, format!("Could not find trait for method {}", - method_type.id)[]); + method_type.id).index(&FullRange)); }, }; qualname.push_str(get_ident(method_type.ident).get()); - let qualname = qualname[]; + let qualname = qualname.index(&FullRange); let sub_span = self.span.sub_span_after_keyword(method_type.span, keywords::Fn); self.fmt.method_decl_str(method_type.span, @@ -1262,7 +1262,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { id, cnum, name, - s[], + s.index(&FullRange), self.cur_scope); }, } @@ -1371,8 +1371,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { } let mut id = String::from_str("$"); - id.push_str(ex.id.to_string()[]); - self.process_formals(&decl.inputs, id[]); + id.push_str(ex.id.to_string().index(&FullRange)); + self.process_formals(&decl.inputs, id.index(&FullRange)); // walk arg and return types for arg in decl.inputs.iter() { @@ -1418,7 +1418,7 @@ 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)[]); + format!("def_map has no key for {} in visit_arm", id).index(&FullRange)); } let def = &(*def_map)[id]; match *def { @@ -1433,8 +1433,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.variable_str(p.span, Some(p.span), id, - path_to_string(p)[], - value[], + path_to_string(p).index(&FullRange), + value.index(&FullRange), "") } def::DefVariant(..) => { @@ -1488,9 +1488,9 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.fmt.variable_str(p.span, sub_span, id, - path_to_string(p)[], - value[], - typ[]); + path_to_string(p).index(&FullRange), + value.index(&FullRange), + typ.index(&FullRange)); } self.collected_paths.clear(); @@ -1509,7 +1509,7 @@ pub fn process_crate(sess: &Session, } assert!(analysis.glob_map.is_some()); - let cratename = match attr::find_crate_name(krate.attrs[]) { + let cratename = match attr::find_crate_name(krate.attrs.index(&FullRange)) { Some(name) => name.get().to_string(), None => { info!("Could not find crate name, using 'unknown_crate'"); @@ -1530,7 +1530,7 @@ pub fn process_crate(sess: &Session, match fs::mkdir_recursive(&root_path, io::USER_RWX) { Err(e) => sess.err(format!("Could not create directory {}: {}", - root_path.display(), e)[]), + root_path.display(), e).index(&FullRange)), _ => (), } @@ -1547,7 +1547,7 @@ pub fn process_crate(sess: &Session, Ok(f) => box f, Err(e) => { let disp = root_path.display(); - sess.fatal(format!("Could not open {}: {}", disp, e)[]); + sess.fatal(format!("Could not open {}: {}", disp, e).index(&FullRange)); } }; root_path.pop(); @@ -1573,7 +1573,7 @@ pub fn process_crate(sess: &Session, cur_scope: 0 }; - visitor.dump_crate_info(cratename[], krate); + visitor.dump_crate_info(cratename.index(&FullRange), krate); visit::walk_crate(&mut visitor, krate); } diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index 679a8d2d07bc8..5352fcc2fedd9 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -41,7 +41,7 @@ impl Recorder { assert!(self.dump_spans); let result = format!("span,kind,{},{},text,\"{}\"\n", kind, su.extent_str(span), escape(su.snippet(span))); - self.record(result[]); + self.record(result.index(&FullRange)); } } @@ -160,15 +160,15 @@ impl<'a> FmtStrs<'a> { if values.len() != fields.len() { self.span.sess.span_bug(span, format!( "Mismatch between length of fields for '{}', expected '{}', found '{}'", - kind, fields.len(), values.len())[]); + kind, fields.len(), values.len()).index(&FullRange)); } let values = values.iter().map(|s| { // Never take more than 1020 chars if s.len() > 1020 { - s[..1020] + s.index(&(0..1020)) } else { - s[] + s.index(&FullRange) } }); @@ -184,7 +184,7 @@ impl<'a> FmtStrs<'a> { } ))); Some(strs.fold(String::new(), |mut s, ss| { - s.push_str(ss[]); + s.push_str(ss.index(&FullRange)); s })) } @@ -198,7 +198,7 @@ impl<'a> FmtStrs<'a> { if needs_span { self.span.sess.span_bug(span, format!( "Called record_without_span for '{}' which does requires a span", - label)[]); + label).index(&FullRange)); } assert!(!dump_spans); @@ -212,9 +212,9 @@ impl<'a> FmtStrs<'a> { }; let mut result = String::from_str(label); - result.push_str(values_str[]); + result.push_str(values_str.index(&FullRange)); result.push_str("\n"); - self.recorder.record(result[]); + self.recorder.record(result.index(&FullRange)); } pub fn record_with_span(&mut self, @@ -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)[]); + which does not require a span", label).index(&FullRange)); } let values_str = match self.make_values_str(label, fields, values, span) { @@ -245,7 +245,7 @@ impl<'a> FmtStrs<'a> { None => return, }; let result = format!("{},{}{}\n", label, self.span.extent_str(sub_span), values_str); - self.recorder.record(result[]); + self.recorder.record(result.index(&FullRange)); } pub fn check_and_record(&mut self, @@ -275,7 +275,7 @@ impl<'a> FmtStrs<'a> { // variable def's node id let mut qualname = String::from_str(name); qualname.push_str("$"); - qualname.push_str(id.to_string()[]); + qualname.push_str(id.to_string().index(&FullRange)); self.check_and_record(Variable, span, sub_span, diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index 14c6475c87df9..8d249b8bfe903 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -218,7 +218,7 @@ impl<'a> SpanUtils<'a> { let loc = self.sess.codemap().lookup_char_pos(span.lo); self.sess.span_bug(span, format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}", - self.snippet(span), loc.file.name, loc.line)[]); + self.snippet(span), loc.file.name, loc.line).index(&FullRange)); } if result.is_none() && prev.tok.is_ident() && bracket_count == 0 { return self.make_sub_span(span, Some(prev.sp)); @@ -244,7 +244,7 @@ impl<'a> SpanUtils<'a> { let loc = self.sess.codemap().lookup_char_pos(span.lo); self.sess.span_bug(span, format!( "Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}", - self.snippet(span), loc.file.name, loc.line)[]); + self.snippet(span), loc.file.name, loc.line).index(&FullRange)); } return result } diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index fed0931cab71d..f55076e7484e5 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -427,7 +427,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let _indenter = indenter(); m.iter().filter_map(|br| { - e(br.pats[]).map(|pats| { + e(br.pats.index(&FullRange)).map(|pats| { let this = br.pats[col]; let mut bound_ptrs = br.bound_ptrs.clone(); match this.node { @@ -471,8 +471,8 @@ fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Collect all of the matches that can match against anything. enter_match(bcx, dm, m, col, val, |pats| { if pat_is_binding_or_wild(dm, &*pats[col]) { - let mut r = pats[..col].to_vec(); - r.push_all(pats[col + 1..]); + let mut r = pats.index(&(0..col)).to_vec(); + r.push_all(pats.index(&((col + 1)..))); Some(r) } else { None @@ -548,7 +548,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>( param_env: param_env, }; enter_match(bcx, dm, m, col, val, |pats| - check_match::specialize(&mcx, pats[], &ctor, col, variant_size) + check_match::specialize(&mcx, pats.index(&FullRange), &ctor, col, variant_size) ) } @@ -790,7 +790,7 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>, let did = langcall(cx, None, format!("comparison of `{}`", - cx.ty_to_string(rhs_t))[], + cx.ty_to_string(rhs_t)).index(&FullRange), StrEqFnLangItem); callee::trans_lang_call(cx, did, &[lhs, rhs], None) } @@ -945,7 +945,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if has_nested_bindings(m, col) { let expanded = expand_nested_bindings(bcx, m, col, val); compile_submatch_continue(bcx, - expanded[], + expanded.index(&FullRange), vals, chk, col, @@ -967,7 +967,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx = compile_guard(bcx, &**guard_expr, m[0].data, - m[1..m.len()], + m.index(&(1..m.len())), vals, chk, has_genuine_default); @@ -990,8 +990,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let tcx = bcx.tcx(); let dm = &tcx.def_map; - let mut vals_left = vals[0u..col].to_vec(); - vals_left.push_all(vals[col + 1u..]); + let mut vals_left = vals.index(&(0u..col)).to_vec(); + vals_left.push_all(vals.index(&((col + 1u)..))); let ccx = bcx.fcx.ccx; // Find a real id (we're adding placeholder wildcard patterns, but @@ -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[]); - compile_submatch(bcx, pats[], vals[], chk, has_genuine_default); + vals.push_all(vals_left.index(&FullRange)); + compile_submatch(bcx, pats.index(&FullRange), vals.index(&FullRange), chk, has_genuine_default); return; } _ => () @@ -1191,10 +1191,10 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } let opt_ms = enter_opt(opt_cx, pat_id, dm, m, opt, col, size, val); let mut opt_vals = unpacked; - opt_vals.push_all(vals_left[]); + opt_vals.push_all(vals_left.index(&FullRange)); compile_submatch(opt_cx, - opt_ms[], - opt_vals[], + opt_ms.index(&FullRange), + opt_vals.index(&FullRange), branch_chk.as_ref().unwrap_or(chk), has_genuine_default); } @@ -1213,8 +1213,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } _ => { compile_submatch(else_cx, - defaults[], - vals_left[], + defaults.index(&FullRange), + vals_left.index(&FullRange), chk, has_genuine_default); } @@ -1333,7 +1333,7 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, "__llmatch"); trmode = TrByCopy(alloca_no_lifetime(bcx, llvariable_ty, - bcx.ident(ident)[])); + bcx.ident(ident).index(&FullRange))); } ast::BindByValue(_) => { // in this case, the final type of the variable will be T, @@ -1341,13 +1341,13 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, // above llmatch = alloca_no_lifetime(bcx, llvariable_ty.ptr_to(), - bcx.ident(ident)[]); + bcx.ident(ident).index(&FullRange)); trmode = TrByMove; } ast::BindByRef(_) => { llmatch = alloca_no_lifetime(bcx, llvariable_ty, - bcx.ident(ident)[]); + bcx.ident(ident).index(&FullRange)); trmode = TrByRef; } }; @@ -1415,7 +1415,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle) }); - compile_submatch(bcx, matches[], &[discr_datum.val], &chk, has_default); + compile_submatch(bcx, matches.index(&FullRange), &[discr_datum.val], &chk, has_default); let mut arm_cxs = Vec::new(); for arm_data in arm_datas.iter() { @@ -1429,7 +1429,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, arm_cxs.push(bcx); } - bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs[]); + bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs.index(&FullRange)); return bcx; } @@ -1582,7 +1582,7 @@ fn mk_binding_alloca<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>, let var_ty = node_id_type(bcx, p_id); // Allocate memory on stack for the binding. - let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident)[]); + let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident).index(&FullRange)); // Subtle: be sure that we *populate* the memory *before* // we schedule the cleanup. @@ -1620,7 +1620,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if bcx.sess().asm_comments() { add_comment(bcx, format!("bind_irrefutable_pat(pat={})", - pat.repr(bcx.tcx()))[]); + pat.repr(bcx.tcx())).index(&FullRange)); } let _indenter = indenter(); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 01b47b728b6ba..60fc29c7c831d 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -154,7 +154,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Repr<'tcx> { match t.sty { ty::ty_tup(ref elems) => { - Univariant(mk_struct(cx, elems[], false, t), false) + Univariant(mk_struct(cx, elems.index(&FullRange), false, t), false) } ty::ty_struct(def_id, substs) => { let fields = ty::lookup_struct_fields(cx.tcx(), def_id); @@ -165,17 +165,17 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); if dtor { ftys.push(cx.tcx().types.bool); } - Univariant(mk_struct(cx, ftys[], packed, t), dtor) + Univariant(mk_struct(cx, ftys.index(&FullRange), packed, t), dtor) } ty::ty_unboxed_closure(def_id, _, substs) => { let typer = NormalizingUnboxedClosureTyper::new(cx.tcx()); let upvars = typer.unboxed_closure_upvars(def_id, substs).unwrap(); let upvar_types = upvars.iter().map(|u| u.ty).collect::>(); - Univariant(mk_struct(cx, upvar_types[], false, t), false) + Univariant(mk_struct(cx, upvar_types.index(&FullRange), false, t), false) } ty::ty_enum(def_id, substs) => { let cases = get_cases(cx.tcx(), def_id, substs); - let hint = *ty::lookup_repr_hints(cx.tcx(), def_id)[].get(0) + let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).index(&FullRange).get(0) .unwrap_or(&attr::ReprAny); let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); @@ -185,7 +185,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // (Typechecking will reject discriminant-sizing attrs.) assert_eq!(hint, attr::ReprAny); let ftys = if dtor { vec!(cx.tcx().types.bool) } else { vec!() }; - return Univariant(mk_struct(cx, ftys[], false, t), + return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t), dtor); } @@ -208,7 +208,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, cx.sess().bug(format!("non-C-like enum {} with specified \ discriminants", ty::item_path_str(cx.tcx(), - def_id))[]); + def_id)).index(&FullRange)); } if cases.len() == 1 { @@ -217,7 +217,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, assert_eq!(hint, attr::ReprAny); let mut ftys = cases[0].tys.clone(); if dtor { ftys.push(cx.tcx().types.bool); } - return Univariant(mk_struct(cx, ftys[], false, t), + return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t), dtor); } @@ -226,7 +226,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let mut discr = 0; while discr < 2 { if cases[1 - discr].is_zerolen(cx, t) { - let st = mk_struct(cx, cases[discr].tys[], + let st = mk_struct(cx, cases[discr].tys.index(&FullRange), false, t); match cases[discr].find_ptr(cx) { Some(ref df) if df.len() == 1 && st.fields.len() == 1 => { @@ -316,17 +316,17 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let fields : Vec<_> = cases.iter().map(|c| { let mut ftys = vec!(ty_of_inttype(cx.tcx(), ity)); - ftys.push_all(c.tys[]); + ftys.push_all(c.tys.index(&FullRange)); if dtor { ftys.push(cx.tcx().types.bool); } - mk_struct(cx, ftys[], false, t) + mk_struct(cx, ftys.index(&FullRange), false, t) }).collect(); - ensure_enum_fits_in_address_space(cx, ity, fields[], t); + ensure_enum_fits_in_address_space(cx, ity, fields.index(&FullRange), t); General(ity, fields, dtor) } _ => cx.sess().bug(format!("adt::represent_type called on non-ADT type: {}", - ty_to_string(cx.tcx(), t))[]) + ty_to_string(cx.tcx(), t)).index(&FullRange)) } } @@ -412,7 +412,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, impl<'tcx> Case<'tcx> { fn is_zerolen<'a>(&self, cx: &CrateContext<'a, 'tcx>, scapegoat: Ty<'tcx>) -> bool { - mk_struct(cx, self.tys[], false, scapegoat).size == 0 + mk_struct(cx, self.tys.index(&FullRange), false, scapegoat).size == 0 } fn find_ptr<'a>(&self, cx: &CrateContext<'a, 'tcx>) -> Option { @@ -451,9 +451,9 @@ fn mk_struct<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, .map(|&ty| type_of::sizing_type_of(cx, ty)).collect() }; - ensure_struct_fits_in_address_space(cx, lltys[], packed, scapegoat); + ensure_struct_fits_in_address_space(cx, lltys.index(&FullRange), packed, scapegoat); - let llty_rec = Type::struct_(cx, lltys[], packed); + let llty_rec = Type::struct_(cx, lltys.index(&FullRange), packed); Struct { size: machine::llsize_of_alloc(cx, llty_rec), align: machine::llalign_of_min(cx, llty_rec), @@ -502,7 +502,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp return ity; } attr::ReprExtern => { - attempts = match cx.sess().target.target.arch[] { + attempts = match cx.sess().target.target.arch.index(&FullRange) { // WARNING: the ARM EABI has two variants; the one corresponding to `at_least_32` // appears to be used on Linux and NetBSD, but some systems may use the variant // corresponding to `choose_shortest`. However, we don't run on those yet...? @@ -628,7 +628,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, match *r { CEnum(..) | General(..) | RawNullablePointer { .. } => { } Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => - llty.set_struct_body(struct_llfields(cx, st, false, false)[], + llty.set_struct_body(struct_llfields(cx, st, false, false).index(&FullRange), st.packed) } } @@ -644,7 +644,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => { match name { None => { - Type::struct_(cx, struct_llfields(cx, st, sizing, dst)[], + Type::struct_(cx, struct_llfields(cx, st, sizing, dst).index(&FullRange), st.packed) } Some(name) => { assert_eq!(sizing, false); Type::named_struct(cx, name) } @@ -663,7 +663,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // of the size. // // FIXME #10604: this breaks when vector types are present. - let (size, align) = union_size_and_align(sts[]); + let (size, align) = union_size_and_align(sts.index(&FullRange)); let align_s = align as u64; let discr_ty = ll_inttype(cx, ity); let discr_size = machine::llsize_of_alloc(cx, discr_ty); @@ -684,10 +684,10 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Type::array(&discr_ty, align_s / discr_size - 1), fill_ty]; match name { - None => Type::struct_(cx, fields[], false), + None => Type::struct_(cx, fields.index(&FullRange), false), Some(name) => { let mut llty = Type::named_struct(cx, name); - llty.set_struct_body(fields[], false); + llty.set_struct_body(fields.index(&FullRange), false); llty } } @@ -765,7 +765,7 @@ pub fn trans_get_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, fn struct_wrapped_nullable_bitdiscr(bcx: Block, nndiscr: Disr, discrfield: &DiscrField, scrutinee: ValueRef) -> ValueRef { - let llptrptr = GEPi(bcx, scrutinee, discrfield[]); + let llptrptr = GEPi(bcx, scrutinee, discrfield.index(&FullRange)); let llptr = Load(bcx, llptrptr); let cmp = if nndiscr == 0 { IntEQ } else { IntNE }; ICmp(bcx, cmp, llptr, C_null(val_ty(llptr))) @@ -853,7 +853,7 @@ pub fn trans_set_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, } StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => { if discr != nndiscr { - let llptrptr = GEPi(bcx, val, discrfield[]); + let llptrptr = GEPi(bcx, val, discrfield.index(&FullRange)); let llptrty = val_ty(llptrptr).element_type(); Store(bcx, C_null(llptrty), llptrptr) } @@ -935,7 +935,7 @@ pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, v let val = if needs_cast { let ccx = bcx.ccx(); let fields = st.fields.iter().map(|&ty| type_of::type_of(ccx, ty)).collect::>(); - let real_ty = Type::struct_(ccx, fields[], st.packed); + let real_ty = Type::struct_(ccx, fields.index(&FullRange), st.packed); PointerCast(bcx, val, real_ty.ptr_to()) } else { val @@ -967,14 +967,14 @@ pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, for (discr, case) in cases.iter().enumerate() { let mut variant_cx = fcx.new_temp_block( - format!("enum-variant-iter-{}", discr.to_string())[] + format!("enum-variant-iter-{}", discr.to_string()).index(&FullRange) ); let rhs_val = C_integral(ll_inttype(ccx, ity), discr as u64, true); AddCase(llswitch, rhs_val, variant_cx.llbb); let fields = case.fields.iter().map(|&ty| type_of::type_of(bcx.ccx(), ty)).collect::>(); - let real_ty = Type::struct_(ccx, fields[], case.packed); + let real_ty = Type::struct_(ccx, fields.index(&FullRange), case.packed); let variant_value = PointerCast(variant_cx, value, real_ty.ptr_to()); variant_cx = f(variant_cx, case, variant_value); @@ -1051,14 +1051,14 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true); let mut f = vec![lldiscr]; f.push_all(vals); - let mut contents = build_const_struct(ccx, case, f[]); + let mut contents = build_const_struct(ccx, case, f.index(&FullRange)); contents.push_all(&[padding(ccx, max_sz - case.size)]); - C_struct(ccx, contents[], false) + C_struct(ccx, contents.index(&FullRange), false) } Univariant(ref st, _dro) => { assert!(discr == 0); let contents = build_const_struct(ccx, st, vals); - C_struct(ccx, contents[], st.packed) + C_struct(ccx, contents.index(&FullRange), st.packed) } RawNullablePointer { nndiscr, nnty, .. } => { if discr == nndiscr { @@ -1072,7 +1072,7 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr if discr == nndiscr { C_struct(ccx, build_const_struct(ccx, nonnull, - vals)[], + vals).index(&FullRange), false) } else { let vals = nonnull.fields.iter().map(|&ty| { @@ -1082,7 +1082,7 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr }).collect::>(); C_struct(ccx, build_const_struct(ccx, nonnull, - vals[])[], + vals.index(&FullRange)).index(&FullRange), false) } } diff --git a/src/librustc_trans/trans/asm.rs b/src/librustc_trans/trans/asm.rs index f18d483f70328..890f046be1b2e 100644 --- a/src/librustc_trans/trans/asm.rs +++ b/src/librustc_trans/trans/asm.rs @@ -71,7 +71,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) callee::DontAutorefArg) }) }).collect::>(); - inputs.push_all(ext_inputs[]); + inputs.push_all(ext_inputs.index(&FullRange)); // no failure occurred preparing operands, no need to cleanup fcx.pop_custom_cleanup_scope(temp_scope); @@ -91,18 +91,18 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) if !clobbers.is_empty() { clobbers.push(','); } - clobbers.push_str(more_clobbers[]); + clobbers.push_str(more_clobbers.index(&FullRange)); } // Add the clobbers to our constraints list if clobbers.len() != 0 && constraints.len() != 0 { constraints.push(','); - constraints.push_str(clobbers[]); + constraints.push_str(clobbers.index(&FullRange)); } else { - constraints.push_str(clobbers[]); + constraints.push_str(clobbers.index(&FullRange)); } - debug!("Asm Constraints: {}", constraints[]); + debug!("Asm Constraints: {}", constraints.index(&FullRange)); let num_outputs = outputs.len(); @@ -112,7 +112,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm) } else if num_outputs == 1 { output_types[0] } else { - Type::struct_(bcx.ccx(), output_types[], false) + Type::struct_(bcx.ccx(), output_types.index(&FullRange), false) }; let dialect = match ia.dialect { diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index edcfaae0f802d..e69bfb57670f3 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -249,7 +249,7 @@ fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>, let f = decl_rust_fn(ccx, fn_ty, name); csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| { - set_llvm_fn_attrs(ccx, attrs[], f) + set_llvm_fn_attrs(ccx, attrs.index(&FullRange), f) }); ccx.externs().borrow_mut().insert(name.to_string(), f); @@ -303,7 +303,7 @@ pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, _ => panic!("expected closure or fn") }; - let llfty = type_of_rust_fn(ccx, env, inputs[], output, abi); + let llfty = type_of_rust_fn(ccx, env, inputs.index(&FullRange), output, abi); debug!("decl_rust_fn(input count={},type={})", inputs.len(), ccx.tn().type_to_string(llfty)); @@ -369,7 +369,7 @@ fn require_alloc_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, Err(s) => { bcx.sess().fatal(format!("allocation of `{}` {}", bcx.ty_to_string(info_ty), - s)[]); + s).index(&FullRange)); } } } @@ -488,7 +488,7 @@ pub fn unset_split_stack(f: ValueRef) { // silently mangles such symbols, breaking our linkage model. pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: String) { if ccx.all_llvm_symbols().borrow().contains(&sym) { - ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym)[]); + ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).index(&FullRange)); } ccx.all_llvm_symbols().borrow_mut().insert(sym); } @@ -525,7 +525,7 @@ pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty::mk_nil(ccx.tcx())); get_extern_fn(ccx, &mut *ccx.externs().borrow_mut(), - name[], + name.index(&FullRange), llvm::CCallConv, llty, dtor_ty) @@ -774,8 +774,8 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let variant_cx = fcx.new_temp_block( format!("enum-iter-variant-{}", - variant.disr_val.to_string()[]) - []); + variant.disr_val.to_string().index(&FullRange)) + .index(&FullRange)); match adt::trans_case(cx, &*repr, variant.disr_val) { _match::SingleResult(r) => { AddCase(llswitch, r.val, variant_cx.llbb) @@ -800,7 +800,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, } _ => { cx.sess().unimpl(format!("type in iter_structural_ty: {}", - ty_to_string(cx.tcx(), t))[]) + ty_to_string(cx.tcx(), t)).index(&FullRange)) } } return cx; @@ -882,7 +882,7 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( } _ => { cx.sess().bug(format!("fail-if-zero on unexpected type: {}", - ty_to_string(cx.tcx(), rhs_t))[]); + ty_to_string(cx.tcx(), rhs_t)).index(&FullRange)); } }; let bcx = with_cond(cx, is_zero, |bcx| { @@ -936,14 +936,14 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty::ty_bare_fn(_, ref fn_ty) => { match ccx.sess().target.target.adjust_abi(fn_ty.abi) { Rust | RustCall => { - get_extern_rust_fn(ccx, t, name[], did) + get_extern_rust_fn(ccx, t, name.index(&FullRange), did) } RustIntrinsic => { ccx.sess().bug("unexpected intrinsic in trans_external_path") } _ => { foreign::register_foreign_item_fn(ccx, fn_ty.abi, t, - name[]) + name.index(&FullRange)) } } } @@ -990,7 +990,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llresult = Invoke(bcx, llfn, - llargs[], + llargs.index(&FullRange), normal_bcx.llbb, landing_pad, Some(attributes)); @@ -1006,7 +1006,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, None => debuginfo::clear_source_location(bcx.fcx) }; - let llresult = Call(bcx, llfn, llargs[], Some(attributes)); + let llresult = Call(bcx, llfn, llargs.index(&FullRange), Some(attributes)); return (llresult, bcx); } } @@ -1123,7 +1123,7 @@ pub fn call_lifetime_end(cx: Block, ptr: ValueRef) { pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, align: u32) { let _icx = push_ctxt("call_memcpy"); let ccx = cx.ccx(); - let key = match ccx.sess().target.target.target_word_size[] { + let key = match ccx.sess().target.target.target_word_size.index(&FullRange) { "32" => "llvm.memcpy.p0i8.p0i8.i32", "64" => "llvm.memcpy.p0i8.p0i8.i64", tws => panic!("Unsupported target word size for memcpy: {}", tws), @@ -1170,7 +1170,7 @@ fn memzero<'a, 'tcx>(b: &Builder<'a, 'tcx>, llptr: ValueRef, ty: Ty<'tcx>) { let llty = type_of::type_of(ccx, ty); - let intrinsic_key = match ccx.sess().target.target.target_word_size[] { + let intrinsic_key = match ccx.sess().target.target.target_word_size.index(&FullRange) { "32" => "llvm.memset.p0i8.i32", "64" => "llvm.memset.p0i8.i64", tws => panic!("Unsupported target word size for memset: {}", tws), @@ -1658,7 +1658,7 @@ fn copy_unboxed_closure_args_to_allocas<'blk, 'tcx>( "argtuple", arg_scope_id)); let untupled_arg_types = match monomorphized_arg_types[0].sty { - ty::ty_tup(ref types) => types[], + ty::ty_tup(ref types) => types.index(&FullRange), _ => { bcx.tcx().sess.span_bug(args[0].pat.span, "first arg to `rust-call` ABI function \ @@ -1846,12 +1846,12 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let arg_datums = if abi != RustCall { create_datums_for_fn_args(&fcx, - monomorphized_arg_types[]) + monomorphized_arg_types.index(&FullRange)) } else { create_datums_for_fn_args_under_call_abi( bcx, arg_scope, - monomorphized_arg_types[]) + monomorphized_arg_types.index(&FullRange)) }; bcx = match closure_env.kind { @@ -1859,16 +1859,16 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, copy_args_to_allocas(&fcx, arg_scope, bcx, - decl.inputs[], + decl.inputs.index(&FullRange), arg_datums) } closure::UnboxedClosure(..) => { copy_unboxed_closure_args_to_allocas( bcx, arg_scope, - decl.inputs[], + decl.inputs.index(&FullRange), arg_datums, - monomorphized_arg_types[]) + monomorphized_arg_types.index(&FullRange)) } }; @@ -1985,7 +1985,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, _ => ccx.sess().bug( format!("trans_enum_variant_constructor: \ unexpected ctor return type {}", - ctor_ty.repr(tcx))[]) + ctor_ty.repr(tcx)).index(&FullRange)) }; // Get location to store the result. If the user does not care about @@ -2008,7 +2008,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, bcx = expr::trans_adt(bcx, result_ty, disr, - fields[], + fields.index(&FullRange), None, expr::SaveIn(llresult), call_info); @@ -2057,7 +2057,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx _ => ccx.sess().bug( format!("trans_enum_variant_or_tuple_like_struct: \ unexpected ctor return type {}", - ty_to_string(ccx.tcx(), ctor_ty))[]) + ty_to_string(ccx.tcx(), ctor_ty)).index(&FullRange)) }; let arena = TypedArena::new(); @@ -2069,7 +2069,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx let arg_tys = ty::ty_fn_args(ctor_ty); - let arg_datums = create_datums_for_fn_args(&fcx, arg_tys[]); + let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.index(&FullRange)); if !type_is_zero_size(fcx.ccx, result_ty.unwrap()) { let dest = fcx.get_ret_slot(bcx, result_ty, "eret_slot"); @@ -2155,7 +2155,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, *lvlsrc.unwrap(), Some(sp), format!("enum variant is more than three times larger \ ({} bytes) than the next largest (ignoring padding)", - largest)[]); + largest).index(&FullRange)); ccx.sess().span_note(enum_def.variants[largest_index].span, "this variant is the largest"); @@ -2239,7 +2239,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[], "linkage") { + if let Some(name) = attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "linkage") { if let Some(linkage) = llvm_linkage_by_name(name.get()) { llvm::SetLinkage(llval, linkage); } else { @@ -2273,7 +2273,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { match item.node { ast::ItemFn(ref decl, _fn_style, abi, ref generics, ref body) => { if !generics.is_type_parameterized() { - let trans_everywhere = attr::requests_inline(item.attrs[]); + let trans_everywhere = attr::requests_inline(item.attrs.index(&FullRange)); // Ignore `trans_everywhere` for cross-crate inlined items // (`from_external`). `trans_item` will be called once for each // compilation unit that references the item, so it will still get @@ -2284,7 +2284,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { foreign::trans_rust_fn_with_foreign_abi(ccx, &**decl, &**body, - item.attrs[], + item.attrs.index(&FullRange), llfn, &Substs::trans_empty(), item.id, @@ -2296,7 +2296,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { llfn, &Substs::trans_empty(), item.id, - item.attrs[]); + item.attrs.index(&FullRange)); } update_linkage(ccx, llfn, @@ -2313,7 +2313,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { ast::ItemImpl(_, _, ref generics, _, _, ref impl_items) => { meth::trans_impl(ccx, item.ident, - impl_items[], + impl_items.index(&FullRange), generics, item.id); } @@ -2343,7 +2343,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { // Do static_assert checking. It can't really be done much earlier // because we need to get the value of the bool out of LLVM - if attr::contains_name(item.attrs[], "static_assert") { + if attr::contains_name(item.attrs.index(&FullRange), "static_assert") { if m == ast::MutMutable { ccx.sess().span_fatal(expr.span, "cannot have static_assert on a mutable \ @@ -2420,7 +2420,7 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, _ => panic!("expected bare rust fn") }; - let llfn = decl_rust_fn(ccx, node_type, sym[]); + let llfn = decl_rust_fn(ccx, node_type, sym.index(&FullRange)); finish_register_fn(ccx, sp, sym, node_id, llfn); llfn } @@ -2462,7 +2462,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty< match fn_sig.0.inputs[1].sty { ty::ty_tup(ref t_in) => { - inputs.push_all(t_in[]); + inputs.push_all(t_in.index(&FullRange)); inputs } _ => ccx.sess().bug("expected tuple'd inputs") @@ -2597,7 +2597,7 @@ 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[], 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 } @@ -2650,7 +2650,7 @@ pub fn create_entry_wrapper(ccx: &CrateContext, let (start_fn, args) = if use_start_lang_item { let start_def_id = match ccx.tcx().lang_items.require(StartFnLangItem) { Ok(id) => id, - Err(s) => { ccx.sess().fatal(s[]); } + Err(s) => { ccx.sess().fatal(s.index(&FullRange)); } }; let start_fn = if start_def_id.krate == ast::LOCAL_CRATE { get_item_val(ccx, start_def_id.node) @@ -2742,7 +2742,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let val = match item { ast_map::NodeItem(i) => { let ty = ty::node_id_to_type(ccx.tcx(), i.id); - let sym = |&:| exported_name(ccx, id, ty, i.attrs[]); + let sym = |&:| exported_name(ccx, id, ty, i.attrs.index(&FullRange)); let v = match i.node { ast::ItemStatic(_, _, ref expr) => { @@ -2765,16 +2765,16 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } else { llvm::LLVMTypeOf(v) }; - if contains_null(sym[]) { + if contains_null(sym.index(&FullRange)) { ccx.sess().fatal( format!("Illegal null byte in export_name \ - value: `{}`", sym)[]); + value: `{}`", sym).index(&FullRange)); } let buf = CString::from_slice(sym.as_bytes()); let g = llvm::LLVMAddGlobal(ccx.llmod(), llty, buf.as_ptr()); - if attr::contains_name(i.attrs[], + if attr::contains_name(i.attrs.index(&FullRange), "thread_local") { llvm::set_thread_local(g, true); } @@ -2799,19 +2799,19 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { sym, i.id) }; - set_llvm_fn_attrs(ccx, i.attrs[], llfn); + set_llvm_fn_attrs(ccx, i.attrs.index(&FullRange), llfn); llfn } _ => panic!("get_item_val: weird result in table") }; - match attr::first_attr_value_str_by_name(i.attrs[], + match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "link_section") { Some(sect) => { if contains_null(sect.get()) { ccx.sess().fatal(format!("Illegal null byte in link_section value: `{}`", - sect.get())[]); + sect.get()).index(&FullRange)); } unsafe { let buf = CString::from_slice(sect.get().as_bytes()); @@ -2854,7 +2854,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let abi = ccx.tcx().map.get_foreign_abi(id); let ty = ty::node_id_to_type(ccx.tcx(), ni.id); let name = foreign::link_name(&*ni); - foreign::register_foreign_item_fn(ccx, abi, ty, name.get()[]) + foreign::register_foreign_item_fn(ccx, abi, ty, name.get().index(&FullRange)) } ast::ForeignItemStatic(..) => { foreign::register_static(ccx, &*ni) @@ -2877,7 +2877,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { let sym = exported_name(ccx, id, ty, - enm.attrs[]); + enm.attrs.index(&FullRange)); llfn = match enm.node { ast::ItemEnum(_, _) => { @@ -2905,7 +2905,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { id, ty, struct_item.attrs - []); + .index(&FullRange)); let llfn = register_fn(ccx, struct_item.span, sym, ctor_id, ty); set_inline_hint(llfn); @@ -2914,7 +2914,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { ref variant => { ccx.sess().bug(format!("get_item_val(): unexpected variant: {}", - variant)[]) + variant).index(&FullRange)) } }; @@ -2935,10 +2935,10 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId, m: &ast::Method) -> ValueRef { let mty = ty::node_id_to_type(ccx.tcx(), id); - let sym = exported_name(ccx, id, mty, m.attrs[]); + let sym = exported_name(ccx, id, mty, m.attrs.index(&FullRange)); let llfn = register_fn(ccx, m.span, sym, id, mty); - set_llvm_fn_attrs(ccx, m.attrs[], llfn); + set_llvm_fn_attrs(ccx, m.attrs.index(&FullRange), llfn); llfn } @@ -2977,7 +2977,7 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &ast::Crate) -> Vec { Some(compressed) => compressed, None => cx.sess().fatal("failed to compress metadata"), }.as_slice()); - let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed[]); + let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed.index(&FullRange)); let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false); let name = format!("rust_metadata_{}_{}", cx.link_meta().crate_name, @@ -3106,7 +3106,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) let link_meta = link::build_link_meta(&tcx.sess, krate, name); let codegen_units = tcx.sess.opts.cg.codegen_units; - let shared_ccx = SharedCrateContext::new(link_meta.crate_name[], + let shared_ccx = SharedCrateContext::new(link_meta.crate_name.index(&FullRange), codegen_units, tcx, export_map, @@ -3208,7 +3208,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) llmod: shared_ccx.metadata_llmod(), }; let formats = shared_ccx.tcx().dependency_formats.borrow().clone(); - let no_builtins = attr::contains_name(krate.attrs[], "no_builtins"); + let no_builtins = attr::contains_name(krate.attrs.index(&FullRange), "no_builtins"); let translation = CrateTranslation { modules: modules, diff --git a/src/librustc_trans/trans/builder.rs b/src/librustc_trans/trans/builder.rs index e09d36ddae923..d0eaf799af1bd 100644 --- a/src/librustc_trans/trans/builder.rs +++ b/src/librustc_trans/trans/builder.rs @@ -552,11 +552,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) { *small_vec_e = C_i32(self.ccx, ix as i32); } - self.inbounds_gep(base, small_vec[..ixs.len()]) + self.inbounds_gep(base, small_vec.index(&(0..ixs.len()))) } else { let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::>(); self.count_insn("gepi"); - self.inbounds_gep(base, v[]) + self.inbounds_gep(base, v.index(&FullRange)) } } @@ -764,8 +764,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let s = format!("{} ({})", text, self.ccx.sess().codemap().span_to_string(sp)); - debug!("{}", s[]); - self.add_comment(s[]); + debug!("{}", s.index(&FullRange)); + self.add_comment(s.index(&FullRange)); } } @@ -802,7 +802,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { }).collect::>(); debug!("Asm Output Type: {}", self.ccx.tn().type_to_string(output)); - let fty = Type::func(argtys[], &output); + let fty = Type::func(argtys.index(&FullRange), &output); unsafe { let v = llvm::LLVMInlineAsm( fty.to_ref(), asm, cons, volatile, alignstack, dia as c_uint); diff --git a/src/librustc_trans/trans/cabi.rs b/src/librustc_trans/trans/cabi.rs index 0e38dd0e5b596..a901142467b8d 100644 --- a/src/librustc_trans/trans/cabi.rs +++ b/src/librustc_trans/trans/cabi.rs @@ -108,7 +108,7 @@ pub fn compute_abi_info(ccx: &CrateContext, atys: &[Type], rty: Type, ret_def: bool) -> FnType { - match ccx.sess().target.target.arch[] { + match ccx.sess().target.target.arch.index(&FullRange) { "x86" => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def), "x86_64" => if ccx.sess().target.target.options.is_like_windows { cabi_x86_win64::compute_abi_info(ccx, atys, rty, ret_def) @@ -119,6 +119,6 @@ pub fn compute_abi_info(ccx: &CrateContext, "aarch64" => cabi_aarch64::compute_abi_info(ccx, atys, rty, ret_def), "mips" => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def), a => ccx.sess().fatal((format!("unrecognized arch \"{}\" in target specification", a)) - []), + .index(&FullRange)), } } diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs index 9ec0c822bf5fe..f40072d1cba3e 100644 --- a/src/librustc_trans/trans/cabi_x86_64.rs +++ b/src/librustc_trans/trans/cabi_x86_64.rs @@ -318,7 +318,7 @@ fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type { tys.push(Type::i64(ccx)); } SSEFv => { - let vec_len = llvec_len(cls[i + 1u..]); + let vec_len = llvec_len(cls.index(&((i + 1u)..))); let vec_ty = Type::vector(&Type::f32(ccx), (vec_len * 2u) as u64); tys.push(vec_ty); i += vec_len; diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 65e6d7e1924b6..498182c17e223 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -114,7 +114,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) expr.span, format!("type of callee is neither bare-fn nor closure: \ {}", - bcx.ty_to_string(datum.ty))[]); + bcx.ty_to_string(datum.ty)).index(&FullRange)); } } } @@ -207,7 +207,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) bcx.tcx().sess.span_bug( ref_expr.span, format!("cannot translate def {} \ - to a callable thing!", def)[]); + to a callable thing!", def).index(&FullRange)); } } } @@ -293,7 +293,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( _ => { tcx.sess.bug(format!("trans_fn_pointer_shim invoked on invalid type: {}", - bare_fn_ty.repr(tcx))[]); + bare_fn_ty.repr(tcx)).index(&FullRange)); } }; let tuple_input_ty = ty::mk_tup(tcx, input_tys.to_vec()); @@ -317,7 +317,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( let llfn = decl_internal_rust_fn(ccx, tuple_fn_ty, - function_name[]); + function_name.index(&FullRange)); // let block_arena = TypedArena::new(); @@ -352,7 +352,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( None, bare_fn_ty, |bcx, _| Callee { bcx: bcx, data: Fn(llfnpointer) }, - ArgVals(llargs[]), + ArgVals(llargs.index(&FullRange)), dest).bcx; finish_fn(&fcx, bcx, output_ty); @@ -775,7 +775,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, // Invoke the actual rust fn and update bcx/llresult. let (llret, b) = base::invoke(bcx, llfn, - llargs[], + llargs.index(&FullRange), callee_ty, call_info); bcx = b; @@ -814,7 +814,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, bcx = foreign::trans_native_call(bcx, callee_ty, llfn, opt_llretslot.unwrap(), - llargs[], arg_tys); + llargs.index(&FullRange), arg_tys); } fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope); diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 79a5898e3d33e..ac64e10ecc809 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -406,7 +406,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { self.ccx.sess().bug( format!("no cleanup scope {} found", - self.ccx.tcx().map.node_to_string(cleanup_scope))[]); + self.ccx.tcx().map.node_to_string(cleanup_scope)).index(&FullRange)); } /// Schedules a cleanup to occur in the top-most scope, which must be a temporary scope. @@ -588,7 +588,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx LoopExit(id, _) => { self.ccx.sess().bug(format!( "cannot exit from scope {}, \ - not in scope", id)[]); + not in scope", id).index(&FullRange)); } } } @@ -657,7 +657,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx let name = scope.block_name("clean"); debug!("generating cleanups for {}", name); let bcx_in = self.new_block(label.is_unwind(), - name[], + name.index(&FullRange), None); let mut bcx_out = bcx_in; for cleanup in scope.cleanups.iter().rev() { @@ -704,7 +704,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx Some(llbb) => { return llbb; } None => { let name = last_scope.block_name("unwind"); - pad_bcx = self.new_block(true, name[], None); + pad_bcx = self.new_block(true, name.index(&FullRange), None); last_scope.cached_landing_pad = Some(pad_bcx.llbb); } } @@ -1025,7 +1025,7 @@ pub fn temporary_scope(tcx: &ty::ctxt, } None => { tcx.sess.bug(format!("no temporary scope available for expr {}", - id)[]) + id).index(&FullRange)) } } } diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index 6f2def16e7674..233cbe8f28003 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -154,7 +154,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let tcx = ccx.tcx(); // compute the type of the closure - let cdata_ty = mk_closure_tys(tcx, bound_values[]); + let cdata_ty = mk_closure_tys(tcx, bound_values.index(&FullRange)); // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a // tuple. This could be a ptr in uniq or a box or on stack, @@ -183,7 +183,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if ccx.sess().asm_comments() { add_comment(bcx, format!("Copy {} into closure", - bv.to_string(ccx))[]); + bv.to_string(ccx)).index(&FullRange)); } let bound_data = GEPi(bcx, llbox, &[0u, abi::BOX_FIELD_BODY, i]); @@ -420,7 +420,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let s = tcx.map.with_path(id, |path| { mangle_internal_name_by_path_and_seq(path, "closure") }); - let llfn = decl_internal_rust_fn(ccx, fty, s[]); + let llfn = decl_internal_rust_fn(ccx, fty, s.index(&FullRange)); // set an inline hint for all closures set_inline_hint(llfn); @@ -444,7 +444,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, &[], ty::ty_fn_ret(fty), ty::ty_fn_abi(fty), - ClosureEnv::new(freevars[], + ClosureEnv::new(freevars.index(&FullRange), BoxedClosure(cdata_ty, store))); fill_fn_pair(bcx, dest_addr, llfn, llbox); bcx @@ -489,7 +489,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext mangle_internal_name_by_path_and_seq(path, "unboxed_closure") }); - let llfn = decl_internal_rust_fn(ccx, function_type, symbol[]); + let llfn = decl_internal_rust_fn(ccx, function_type, symbol.index(&FullRange)); // set an inline hint for all closures set_inline_hint(llfn); @@ -542,7 +542,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>( &[], function_type.sig.0.output, function_type.abi, - ClosureEnv::new(freevars[], + ClosureEnv::new(freevars.index(&FullRange), UnboxedClosure(freevar_mode))); // Don't hoist this to the top of the function. It's perfectly legitimate @@ -579,3 +579,4 @@ pub fn trans_unboxed_closure<'blk, 'tcx>( bcx } + diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 094f98e988aad..8596583d4a592 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -218,7 +218,7 @@ pub fn gensym_name(name: &str) -> PathElem { let num = token::gensym(name).uint(); // use one colon which will get translated to a period by the mangler, and // we're guaranteed that `num` is globally unique for this crate. - PathName(token::gensym(format!("{}:{}", name, num)[])) + PathName(token::gensym(format!("{}:{}", name, num).index(&FullRange))) } #[derive(Copy)] @@ -546,7 +546,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> { Some(v) => v.clone(), None => { self.tcx().sess.bug(format!( - "no def associated with node id {}", nid)[]); + "no def associated with node id {}", nid).index(&FullRange)); } } } @@ -976,7 +976,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, span, format!("Encountered error `{}` selecting `{}` during trans", e.repr(tcx), - trait_ref.repr(tcx))[]) + trait_ref.repr(tcx)).index(&FullRange)) } }; @@ -1069,7 +1069,7 @@ pub fn drain_fulfillment_cx<'a,'tcx,T>(span: Span, infcx.tcx.sess.span_bug( span, format!("Encountered errors `{}` fulfilling during trans", - errors.repr(infcx.tcx))[]); + errors.repr(infcx.tcx)).index(&FullRange)); } } } @@ -1109,7 +1109,7 @@ pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, if substs.types.any(|t| ty::type_needs_infer(*t)) { tcx.sess.bug(format!("type parameters for node {} include inference types: {}", - node, substs.repr(tcx))[]); + node, substs.repr(tcx)).index(&FullRange)); } monomorphize::apply_param_substs(tcx, @@ -1127,8 +1127,8 @@ pub fn langcall(bcx: Block, Err(s) => { let msg = format!("{} {}", msg, s); match span { - Some(span) => bcx.tcx().sess.span_fatal(span, msg[]), - None => bcx.tcx().sess.fatal(msg[]), + Some(span) => bcx.tcx().sess.span_fatal(span, msg.index(&FullRange)), + None => bcx.tcx().sess.fatal(msg.index(&FullRange)), } } } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index a3861e71d83de..f9b14e1de4fdb 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -54,7 +54,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) _ => cx.sess().span_bug(lit.span, format!("integer literal has type {} (expected int \ or uint)", - ty_to_string(cx.tcx(), lit_int_ty))[]) + ty_to_string(cx.tcx(), lit_int_ty)).index(&FullRange)) } } ast::LitFloat(ref fs, t) => { @@ -74,7 +74,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) } ast::LitBool(b) => C_bool(cx, b), ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()), - ast::LitBinary(ref data) => C_binary_slice(cx, data[]), + ast::LitBinary(ref data) => C_binary_slice(cx, data.index(&FullRange)), } } @@ -93,9 +93,9 @@ fn const_vec(cx: &CrateContext, e: &ast::Expr, .collect::>(); // If the vector contains enums, an LLVM array won't work. let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) { - C_struct(cx, vs[], false) + C_struct(cx, vs.index(&FullRange), false) } else { - C_array(llunitty, vs[]) + C_array(llunitty, vs.index(&FullRange)) }; (v, llunitty) } @@ -149,13 +149,13 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, v: ValueRef, } _ => { cx.sess().bug(format!("unexpected dereferenceable type {}", - ty_to_string(cx.tcx(), t))[]) + ty_to_string(cx.tcx(), t)).index(&FullRange)) } } } None => { cx.sess().bug(format!("cannot dereference const of type {}", - ty_to_string(cx.tcx(), t))[]) + ty_to_string(cx.tcx(), t)).index(&FullRange)) } } } @@ -252,7 +252,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) } _ => cx.sess().span_bug(e.span, format!("unimplemented type in const unsize: {}", - ty_to_string(cx.tcx(), ty))[]) + ty_to_string(cx.tcx(), ty)).index(&FullRange)) } } _ => { @@ -260,7 +260,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) .span_bug(e.span, format!("unimplemented const \ autoref {}", - autoref)[]) + autoref).index(&FullRange)) } } } @@ -281,7 +281,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) } cx.sess().bug(format!("const {} of type {} has size {} instead of {}", e.repr(cx.tcx()), ty_to_string(cx.tcx(), ety), - csize, tsize)[]); + csize, tsize).index(&FullRange)); } (llconst, ety_adjusted) } @@ -431,7 +431,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { _ => cx.sess().span_bug(base.span, format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt))[]) + ty_to_string(cx.tcx(), bt)).index(&FullRange)) }, ty::ty_rptr(_, mt) => match mt.ty.sty { ty::ty_vec(_, Some(u)) => { @@ -440,12 +440,12 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { _ => cx.sess().span_bug(base.span, format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt))[]) + ty_to_string(cx.tcx(), bt)).index(&FullRange)) }, _ => cx.sess().span_bug(base.span, format!("index-expr base must be a vector \ or string type, found {}", - ty_to_string(cx.tcx(), bt))[]) + ty_to_string(cx.tcx(), bt)).index(&FullRange)) }; let len = llvm::LLVMConstIntGetZExtValue(len) as u64; @@ -546,8 +546,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { ast::ExprTup(ref es) => { let ety = ty::expr_ty(cx.tcx(), e); let repr = adt::represent_type(cx, ety); - let vals = map_list(es[]); - adt::trans_const(cx, &*repr, 0, vals[]) + let vals = map_list(es.index(&FullRange)); + adt::trans_const(cx, &*repr, 0, vals.index(&FullRange)) } ast::ExprStruct(_, ref fs, ref base_opt) => { let ety = ty::expr_ty(cx.tcx(), e); @@ -578,7 +578,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { } } }).collect::>(); - adt::trans_const(cx, &*repr, discr, cs[]) + adt::trans_const(cx, &*repr, discr, cs.index(&FullRange)) }) } ast::ExprVec(ref es) => { @@ -595,9 +595,9 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { }; let vs: Vec<_> = repeat(const_expr(cx, &**elem).0).take(n).collect(); if vs.iter().any(|vi| val_ty(*vi) != llunitty) { - C_struct(cx, vs[], false) + C_struct(cx, vs.index(&FullRange), false) } else { - C_array(llunitty, vs[]) + C_array(llunitty, vs.index(&FullRange)) } } ast::ExprPath(_) => { @@ -645,8 +645,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { Some(def::DefStruct(_)) => { let ety = ty::expr_ty(cx.tcx(), e); let repr = adt::represent_type(cx, ety); - let arg_vals = map_list(args[]); - adt::trans_const(cx, &*repr, 0, arg_vals[]) + let arg_vals = map_list(args.index(&FullRange)); + adt::trans_const(cx, &*repr, 0, arg_vals.index(&FullRange)) } Some(def::DefVariant(enum_did, variant_did, _)) => { let ety = ty::expr_ty(cx.tcx(), e); @@ -654,11 +654,11 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef { let vinfo = ty::enum_variant_with_id(cx.tcx(), enum_did, variant_did); - let arg_vals = map_list(args[]); + let arg_vals = map_list(args.index(&FullRange)); adt::trans_const(cx, &*repr, vinfo.disr_val, - arg_vals[]) + arg_vals.index(&FullRange)) } _ => cx.sess().span_bug(e.span, "expected a struct or variant def") } diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs index 3726cf14023ee..585b338b0262b 100644 --- a/src/librustc_trans/trans/context.rs +++ b/src/librustc_trans/trans/context.rs @@ -284,7 +284,7 @@ impl<'tcx> SharedCrateContext<'tcx> { // such as a function name in the module. // 1. http://llvm.org/bugs/show_bug.cgi?id=11479 let llmod_id = format!("{}.{}.rs", crate_name, i); - let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id[]); + let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id.index(&FullRange)); shared_ccx.local_ccxs.push(local_ccx); } @@ -374,7 +374,7 @@ impl<'tcx> LocalCrateContext<'tcx> { .target .target .data_layout - []); + .index(&FullRange)); let dbg_cx = if shared.tcx.sess.opts.debuginfo != NoDebugInfo { Some(debuginfo::CrateDebugContext::new(llmod)) @@ -721,7 +721,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { /// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable /// address space on 64-bit ARMv8 and x86_64. pub fn obj_size_bound(&self) -> u64 { - match self.sess().target.target.target_word_size[] { + match self.sess().target.target.target_word_size.index(&FullRange) { "32" => 1 << 31, "64" => 1 << 47, _ => unreachable!() // error handled by config::build_target_config @@ -731,7 +731,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! { self.sess().fatal( format!("the type `{}` is too big for the current architecture", - obj.repr(self.tcx()))[]) + obj.repr(self.tcx())).index(&FullRange)) } } diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index 768de89d5935d..67e8b4f686a3d 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -48,7 +48,7 @@ pub fn trans_stmt<'blk, 'tcx>(cx: Block<'blk, 'tcx>, debug!("trans_stmt({})", s.repr(cx.tcx())); if cx.sess().asm_comments() { - add_span_comment(cx, s.span, s.repr(cx.tcx())[]); + add_span_comment(cx, s.span, s.repr(cx.tcx()).index(&FullRange)); } let mut bcx = cx; @@ -188,7 +188,7 @@ pub fn trans_if<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } let name = format!("then-block-{}-", thn.id); - let then_bcx_in = bcx.fcx.new_id_block(name[], thn.id); + let then_bcx_in = bcx.fcx.new_id_block(name.index(&FullRange), thn.id); let then_bcx_out = trans_block(then_bcx_in, &*thn, dest); trans::debuginfo::clear_source_location(bcx.fcx); @@ -437,7 +437,7 @@ pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, Some(&def::DefLabel(loop_id)) => loop_id, ref r => { bcx.tcx().sess.bug(format!("{} in def-map for label", - r)[]) + r).index(&FullRange)) } } } @@ -501,7 +501,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let v_str = C_str_slice(ccx, fail_str); let loc = bcx.sess().codemap().lookup_char_pos(sp.lo); - let filename = token::intern_and_get_ident(loc.file.name[]); + let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); let filename = C_str_slice(ccx, filename); let line = C_uint(ccx, loc.line); let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false); @@ -510,7 +510,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let did = langcall(bcx, Some(sp), "", PanicFnLangItem); let bcx = callee::trans_lang_call(bcx, did, - args[], + args.index(&FullRange), Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; @@ -526,7 +526,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Extract the file/line from the span let loc = bcx.sess().codemap().lookup_char_pos(sp.lo); - let filename = token::intern_and_get_ident(loc.file.name[]); + let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); // Invoke the lang item let filename = C_str_slice(ccx, filename); @@ -537,7 +537,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let did = langcall(bcx, Some(sp), "", PanicBoundsCheckFnLangItem); let bcx = callee::trans_lang_call(bcx, did, - args[], + args.index(&FullRange), Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index d73b3f6b4e420..6a1df82056d49 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -464,7 +464,7 @@ impl<'tcx> Datum<'tcx, Lvalue> { } _ => bcx.tcx().sess.bug( format!("Unexpected unsized type in get_element: {}", - bcx.ty_to_string(self.ty))[]) + bcx.ty_to_string(self.ty)).index(&FullRange)) }; Datum { val: val, diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 3f0f7fd9bd303..5777ee7880012 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -285,7 +285,7 @@ impl<'tcx> TypeMap<'tcx> { metadata: DIType) { if self.type_to_metadata.insert(type_, metadata).is_some() { cx.sess().bug(format!("Type metadata for Ty '{}' is already in the TypeMap!", - ppaux::ty_to_string(cx.tcx(), type_))[]); + ppaux::ty_to_string(cx.tcx(), type_)).index(&FullRange)); } } @@ -298,7 +298,7 @@ impl<'tcx> TypeMap<'tcx> { if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() { let unique_type_id_str = self.get_unique_type_id_as_string(unique_type_id); cx.sess().bug(format!("Type metadata for unique id '{}' is already in the TypeMap!", - unique_type_id_str[])[]); + unique_type_id_str.index(&FullRange)).index(&FullRange)); } } @@ -335,13 +335,13 @@ impl<'tcx> TypeMap<'tcx> { // unique ptr (~) -> {~ :pointee-uid:} // @-ptr (@) -> {@ :pointee-uid:} // sized vec ([T; x]) -> {[:size:] :element-uid:} - // unsized vec ([T]) -> {[] :element-uid:} + // unsized vec ([T]) -> {.index(&FullRange) :element-uid:} // trait (T) -> {trait_:svh: / :node-id:_<(:param-uid:),*> } // closure -> { :store-sigil: |(:param-uid:),* <,_...>| -> \ // :return-type-uid: : (:bounds:)*} // function -> { fn( (:param-uid:)* <,_...> ) -> \ // :return-type-uid:} - // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>} + // unique vec box (~.index(&FullRange)) -> {HEAP_VEC_BOX<:pointee-uid:>} // gc box -> {GC_BOX<:pointee-uid:>} match self.type_to_unique_id.get(&type_).cloned() { @@ -379,14 +379,14 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, component_type); let component_type_id = self.get_unique_type_id_as_string(component_type_id); - unique_type_id.push_str(component_type_id[]); + unique_type_id.push_str(component_type_id.index(&FullRange)); } }, ty::ty_uniq(inner_type) => { unique_type_id.push('~'); let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id[]); + unique_type_id.push_str(inner_type_id.index(&FullRange)); }, ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => { unique_type_id.push('*'); @@ -396,7 +396,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id[]); + unique_type_id.push_str(inner_type_id.index(&FullRange)); }, ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => { unique_type_id.push('&'); @@ -406,21 +406,21 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id[]); + unique_type_id.push_str(inner_type_id.index(&FullRange)); }, ty::ty_vec(inner_type, optional_length) => { match optional_length { Some(len) => { - unique_type_id.push_str(format!("[{}]", len)[]); + unique_type_id.push_str(format!("[{}]", len).index(&FullRange)); } None => { - unique_type_id.push_str("[]"); + unique_type_id.push_str(".index(&FullRange)"); } }; let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); - unique_type_id.push_str(inner_type_id[]); + unique_type_id.push_str(inner_type_id.index(&FullRange)); }, ty::ty_trait(ref trait_data) => { unique_type_id.push_str("trait "); @@ -445,7 +445,7 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = self.get_unique_type_id_as_string(parameter_type_id); - unique_type_id.push_str(parameter_type_id[]); + unique_type_id.push_str(parameter_type_id.index(&FullRange)); unique_type_id.push(','); } @@ -458,7 +458,7 @@ impl<'tcx> TypeMap<'tcx> { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); - unique_type_id.push_str(return_type_id[]); + unique_type_id.push_str(return_type_id.index(&FullRange)); } ty::FnDiverging => { unique_type_id.push_str("!"); @@ -474,8 +474,8 @@ impl<'tcx> TypeMap<'tcx> { }, _ => { cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {}", - ppaux::ty_to_string(cx.tcx(), type_)[], - type_.sty)[]) + ppaux::ty_to_string(cx.tcx(), type_).index(&FullRange), + type_.sty).index(&FullRange)) } }; @@ -518,7 +518,7 @@ impl<'tcx> TypeMap<'tcx> { output.push_str(crate_hash.as_str()); output.push_str("/"); - output.push_str(format!("{:x}", def_id.node)[]); + output.push_str(format!("{:x}", def_id.node).index(&FullRange)); // Maybe check that there is no self type here. @@ -531,7 +531,7 @@ impl<'tcx> TypeMap<'tcx> { type_map.get_unique_type_id_of_type(cx, type_parameter); let param_type_id = type_map.get_unique_type_id_as_string(param_type_id); - output.push_str(param_type_id[]); + output.push_str(param_type_id.index(&FullRange)); output.push(','); } @@ -573,7 +573,7 @@ impl<'tcx> TypeMap<'tcx> { self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = self.get_unique_type_id_as_string(parameter_type_id); - unique_type_id.push_str(parameter_type_id[]); + unique_type_id.push_str(parameter_type_id.index(&FullRange)); unique_type_id.push(','); } @@ -587,7 +587,7 @@ impl<'tcx> TypeMap<'tcx> { ty::FnConverging(ret_ty) => { let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty); let return_type_id = self.get_unique_type_id_as_string(return_type_id); - unique_type_id.push_str(return_type_id[]); + unique_type_id.push_str(return_type_id.index(&FullRange)); } ty::FnDiverging => { unique_type_id.push_str("!"); @@ -618,7 +618,7 @@ impl<'tcx> TypeMap<'tcx> { let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type); let enum_variant_type_id = format!("{}::{}", self.get_unique_type_id_as_string(enum_type_id) - [], + .index(&FullRange), variant_name); let interner_key = self.unique_id_interner.intern(Rc::new(enum_variant_type_id)); UniqueTypeId(interner_key) @@ -799,19 +799,19 @@ pub fn create_global_var_metadata(cx: &CrateContext, create_global_var_metadata() - Captured var-id refers to \ unexpected ast_item variant: {}", - var_item)[]) + var_item).index(&FullRange)) } } }, _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \ - Captured var-id refers to unexpected \ ast_map variant: {}", - var_item)[]) + var_item).index(&FullRange)) }; let (file_metadata, line_number) = if span != codemap::DUMMY_SP { let loc = span_start(cx, span); - (file_metadata(cx, loc.file.name[]), loc.line as c_uint) + (file_metadata(cx, loc.file.name.index(&FullRange)), loc.line as c_uint) } else { (UNKNOWN_FILE_METADATA, UNKNOWN_LINE_NUMBER) }; @@ -822,7 +822,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id)); let var_name = token::get_ident(ident).get().to_string(); let linkage_name = - namespace_node.mangled_name_of_contained_item(var_name[]); + namespace_node.mangled_name_of_contained_item(var_name.index(&FullRange)); let var_scope = namespace_node.scope; let var_name = CString::from_slice(var_name.as_bytes()); @@ -861,7 +861,7 @@ pub fn create_local_var_metadata(bcx: Block, local: &ast::Local) { None => { bcx.sess().span_bug(span, format!("no entry in lllocals table for {}", - node_id)[]); + node_id).index(&FullRange)); } }; @@ -915,7 +915,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, "debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ ast_map variant: {}", - ast_item)[]); + ast_item).index(&FullRange)); } } } @@ -925,7 +925,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, format!("debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ ast_map variant: {}", - ast_item)[]); + ast_item).index(&FullRange)); } }; @@ -955,7 +955,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let variable_access = IndirectVariable { alloca: env_pointer, - address_operations: address_operations[..address_op_count] + address_operations: address_operations.index(&(0..address_op_count)) }; declare_local(bcx, @@ -1032,7 +1032,7 @@ pub fn create_argument_metadata(bcx: Block, arg: &ast::Arg) { None => { bcx.sess().span_bug(span, format!("no entry in lllocals table for {}", - node_id)[]); + node_id).index(&FullRange)); } }; @@ -1146,7 +1146,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if let Some(code_snippet) = code_snippet { let bytes = code_snippet.as_bytes(); - if bytes.len() > 0 && bytes[bytes.len()-1 ..] == b"}" { + if bytes.len() > 0 && bytes.index(&((bytes.len()-1)..)) == b"}" { cleanup_span = Span { lo: node_span.hi - codemap::BytePos(1), hi: node_span.hi, @@ -1290,7 +1290,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, match expr.node { ast::ExprClosure(_, _, ref fn_decl, ref top_level_block) => { let name = format!("fn{}", token::gensym("fn")); - let name = token::str_to_ident(name[]); + let name = token::str_to_ident(name.index(&FullRange)); (name, &**fn_decl, // This is not quite right. It should actually inherit // the generics of the enclosing function. @@ -1322,7 +1322,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, cx.sess() .bug(format!("create_function_debug_context: \ unexpected sort of node: {}", - fnitem)[]) + fnitem).index(&FullRange)) } } } @@ -1333,7 +1333,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } _ => cx.sess().bug(format!("create_function_debug_context: \ unexpected sort of node: {}", - fnitem)[]) + fnitem).index(&FullRange)) }; // This can be the case for functions inlined from another crate @@ -1342,7 +1342,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } let loc = span_start(cx, span); - let file_metadata = file_metadata(cx, loc.file.name[]); + let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); let function_type_metadata = unsafe { let fn_signature = get_function_signature(cx, @@ -1369,7 +1369,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (linkage_name, containing_scope) = if has_path { let namespace_node = namespace_for_item(cx, ast_util::local_def(fn_ast_id)); let linkage_name = namespace_node.mangled_name_of_contained_item( - function_name[]); + function_name.index(&FullRange)); let containing_scope = namespace_node.scope; (linkage_name, containing_scope) } else { @@ -1457,7 +1457,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP)); } - return create_DIArray(DIB(cx), signature[]); + return create_DIArray(DIB(cx), signature.index(&FullRange)); } fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, @@ -1492,7 +1492,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, actual_self_type, true); - name_to_append_suffix_to.push_str(actual_self_type_name[]); + name_to_append_suffix_to.push_str(actual_self_type_name.index(&FullRange)); if generics.is_type_parameterized() { name_to_append_suffix_to.push_str(","); @@ -1531,7 +1531,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let actual_type_name = compute_debuginfo_type_name(cx, actual_type, true); - name_to_append_suffix_to.push_str(actual_type_name[]); + name_to_append_suffix_to.push_str(actual_type_name.index(&FullRange)); if index != generics.ty_params.len() - 1 { name_to_append_suffix_to.push_str(","); @@ -1558,7 +1558,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, name_to_append_suffix_to.push('>'); - return create_DIArray(DIB(cx), template_params[]); + return create_DIArray(DIB(cx), template_params.index(&FullRange)); } } @@ -1652,7 +1652,7 @@ fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let cx: &CrateContext = bcx.ccx(); let filename = span_start(cx, span).file.name.clone(); - let file_metadata = file_metadata(cx, filename[]); + let file_metadata = file_metadata(cx, filename.index(&FullRange)); let name = token::get_ident(variable_ident); let loc = span_start(cx, span); @@ -1738,7 +1738,7 @@ fn file_metadata(cx: &CrateContext, full_path: &str) -> DIFile { let work_dir = cx.sess().working_dir.as_str().unwrap(); let file_name = if full_path.starts_with(work_dir) { - full_path[work_dir.len() + 1u..full_path.len()] + full_path.index(&((work_dir.len() + 1u)..full_path.len())) } else { full_path }; @@ -1770,7 +1770,7 @@ fn scope_metadata(fcx: &FunctionContext, fcx.ccx.sess().span_bug(error_reporting_span, format!("debuginfo: Could not find scope info for node {}", - node)[]); + node).index(&FullRange)); } } } @@ -1966,7 +1966,7 @@ impl<'tcx> RecursiveTypeDescription<'tcx> { cx.sess().bug(format!("Forward declaration of potentially recursive type \ '{}' was not found in TypeMap!", ppaux::ty_to_string(cx.tcx(), unfinished_type)) - []); + .index(&FullRange)); } } @@ -1978,7 +1978,7 @@ impl<'tcx> RecursiveTypeDescription<'tcx> { set_members_of_composite_type(cx, metadata_stub, llvm_type, - member_descriptions[]); + member_descriptions.index(&FullRange)); return MetadataCreationResult::new(metadata_stub, true); } } @@ -2050,7 +2050,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let struct_metadata_stub = create_struct_stub(cx, struct_llvm_type, - struct_name[], + struct_name.index(&FullRange), unique_type_id, containing_scope); @@ -2111,7 +2111,7 @@ fn prepare_tuple_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id, create_struct_stub(cx, tuple_llvm_type, - tuple_name[], + tuple_name.index(&FullRange), unique_type_id, UNKNOWN_SCOPE_METADATA), tuple_llvm_type, @@ -2171,7 +2171,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - member_descriptions[]); + member_descriptions.index(&FullRange)); MemberDescription { name: "".to_string(), llvm_type: variant_llvm_type, @@ -2204,7 +2204,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - member_descriptions[]); + member_descriptions.index(&FullRange)); vec![ MemberDescription { name: "".to_string(), @@ -2304,7 +2304,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - variant_member_descriptions[]); + variant_member_descriptions.index(&FullRange)); // Encode the information about the null variant in the union // member's name. @@ -2383,7 +2383,7 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, .iter() .map(|&t| type_of::type_of(cx, t)) .collect::>() - [], + .index(&FullRange), struct_def.packed); // Could do some consistency checks here: size, align, field count, discr type @@ -2450,7 +2450,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, enum_def_id); let loc = span_start(cx, definition_span); - let file_metadata = file_metadata(cx, loc.file.name[]); + let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); let variants = ty::enum_variants(cx.tcx(), enum_def_id); @@ -2637,7 +2637,7 @@ fn set_members_of_composite_type(cx: &CrateContext, Please use a rustc built with anewer \ version of LLVM.", llvm_version_major, - llvm_version_minor)[]); + llvm_version_minor).index(&FullRange)); } else { cx.sess().bug("debuginfo::set_members_of_composite_type() - \ Already completed forward declaration re-encountered."); @@ -2675,7 +2675,7 @@ fn set_members_of_composite_type(cx: &CrateContext, .collect(); unsafe { - let type_array = create_DIArray(DIB(cx), member_metadata[]); + let type_array = create_DIArray(DIB(cx), member_metadata.index(&FullRange)); llvm::LLVMDICompositeTypeSetTypeArray(composite_type_metadata, type_array); } } @@ -2774,7 +2774,7 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let member_llvm_types = slice_llvm_type.field_types(); assert!(slice_layout_is_correct(cx, - member_llvm_types[], + member_llvm_types.index(&FullRange), element_type)); let member_descriptions = [ MemberDescription { @@ -2796,11 +2796,11 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, assert!(member_descriptions.len() == member_llvm_types.len()); let loc = span_start(cx, span); - let file_metadata = file_metadata(cx, loc.file.name[]); + let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); let metadata = composite_type_metadata(cx, slice_llvm_type, - slice_type_name[], + slice_type_name.index(&FullRange), unique_type_id, &member_descriptions, UNKNOWN_SCOPE_METADATA, @@ -2846,7 +2846,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, llvm::LLVMDIBuilderCreateSubroutineType( DIB(cx), UNKNOWN_FILE_METADATA, - create_DIArray(DIB(cx), signature_metadata[])) + create_DIArray(DIB(cx), signature_metadata.index(&FullRange))) }, false); } @@ -2872,7 +2872,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type); cx.sess().bug(format!("debuginfo: Unexpected trait-object type in \ trait_pointer_metadata(): {}", - pp_type_name[])[]); + pp_type_name.index(&FullRange)).index(&FullRange)); } }; @@ -2886,7 +2886,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, composite_type_metadata(cx, trait_llvm_type, - trait_type_name[], + trait_type_name.index(&FullRange), unique_type_id, &[], containing_scope, @@ -3006,13 +3006,13 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_tup(ref elements) => { prepare_tuple_metadata(cx, t, - elements[], + elements.index(&FullRange), unique_type_id, usage_site_span).finalize(cx) } _ => { cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {}", - sty)[]) + sty).index(&FullRange)) } }; @@ -3030,9 +3030,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, type id '{}' to already be in \ the debuginfo::TypeMap but it \ was not. (Ty = {})", - unique_type_id_str[], + unique_type_id_str.index(&FullRange), ppaux::ty_to_string(cx.tcx(), t)); - cx.sess().span_bug(usage_site_span, error_message[]); + cx.sess().span_bug(usage_site_span, error_message.index(&FullRange)); } }; @@ -3045,9 +3045,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, UniqueTypeId maps in \ debuginfo::TypeMap. \ UniqueTypeId={}, Ty={}", - unique_type_id_str[], + unique_type_id_str.index(&FullRange), ppaux::ty_to_string(cx.tcx(), t)); - cx.sess().span_bug(usage_site_span, error_message[]); + cx.sess().span_bug(usage_site_span, error_message.index(&FullRange)); } } None => { @@ -3253,7 +3253,7 @@ fn create_scope_map(cx: &CrateContext, { // Create a new lexical scope and push it onto the stack let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo); - let file_metadata = file_metadata(cx, loc.file.name[]); + let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); let parent_scope = scope_stack.last().unwrap().scope_metadata; let scope_metadata = unsafe { @@ -3375,7 +3375,7 @@ fn create_scope_map(cx: &CrateContext, if need_new_scope { // Create a new lexical scope and push it onto the stack let loc = cx.sess().codemap().lookup_char_pos(pat.span.lo); - let file_metadata = file_metadata(cx, loc.file.name[]); + let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange)); let parent_scope = scope_stack.last().unwrap().scope_metadata; let scope_metadata = unsafe { @@ -3849,7 +3849,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::ty_projection(..) | ty::ty_param(_) => { cx.sess().bug(format!("debuginfo: Trying to create type name for \ - unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]); + unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange)); } } @@ -3932,13 +3932,13 @@ impl NamespaceTreeNode { None => {} } let string = token::get_name(node.name); - output.push_str(format!("{}", string.get().len())[]); + output.push_str(format!("{}", string.get().len()).index(&FullRange)); output.push_str(string.get()); } let mut name = String::from_str("_ZN"); fill_nested(self, &mut name); - name.push_str(format!("{}", item_name.len())[]); + name.push_str(format!("{}", item_name.len()).index(&FullRange)); name.push_str(item_name); name.push('E'); name @@ -3946,7 +3946,7 @@ impl NamespaceTreeNode { } fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str { - cx.link_meta().crate_name[] + cx.link_meta().crate_name.index(&FullRange) } fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc { @@ -4023,7 +4023,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc { cx.sess().bug(format!("debuginfo::namespace_for_item(): \ path too short for {}", - def_id)[]); + def_id).index(&FullRange)); } } }) diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 9221ae09df98a..fe5333061c700 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -318,7 +318,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, unsized_info(bcx, k, id, ty_substs[tp_index], identity) } _ => bcx.sess().bug(format!("UnsizeStruct with bad sty: {}", - bcx.ty_to_string(unadjusted_ty))[]) + bcx.ty_to_string(unadjusted_ty)).index(&FullRange)) }, &ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => { // Note that we preserve binding levels here: @@ -451,7 +451,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let unboxed_ty = match datum_ty.sty { ty::ty_uniq(t) => t, _ => bcx.sess().bug(format!("Expected ty_uniq, found {}", - bcx.ty_to_string(datum_ty))[]) + bcx.ty_to_string(datum_ty)).index(&FullRange)) }; let result_ty = ty::mk_uniq(tcx, ty::unsize_ty(tcx, unboxed_ty, k, expr.span)); @@ -657,7 +657,7 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr.span, format!("trans_rvalue_datum_unadjusted reached \ fall-through case: {}", - expr.node)[]); + expr.node).index(&FullRange)); } } } @@ -1006,7 +1006,7 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr.span, format!("trans_rvalue_stmt_unadjusted reached \ fall-through case: {}", - expr.node)[]); + expr.node).index(&FullRange)); } } } @@ -1032,14 +1032,14 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, controlflow::trans_if(bcx, expr.id, &**cond, &**thn, els.as_ref().map(|e| &**e), dest) } ast::ExprMatch(ref discr, ref arms, _) => { - _match::trans_match(bcx, expr, &**discr, arms[], dest) + _match::trans_match(bcx, expr, &**discr, arms.index(&FullRange), dest) } ast::ExprBlock(ref blk) => { controlflow::trans_block(bcx, &**blk, dest) } ast::ExprStruct(_, ref fields, ref base) => { trans_struct(bcx, - fields[], + fields.index(&FullRange), base.as_ref().map(|e| &**e), expr.span, expr.id, @@ -1104,7 +1104,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_adt(bcx, expr_ty(bcx, expr), 0, - numbered_fields[], + numbered_fields.index(&FullRange), None, dest, Some(NodeInfo { id: expr.id, span: expr.span })) @@ -1148,13 +1148,13 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_overloaded_call(bcx, expr, &**f, - args[], + args.index(&FullRange), Some(dest)) } else { callee::trans_call(bcx, expr, &**f, - callee::ArgExprs(args[]), + callee::ArgExprs(args.index(&FullRange)), dest) } } @@ -1162,7 +1162,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, callee::trans_method_call(bcx, expr, &*args[0], - callee::ArgExprs(args[]), + callee::ArgExprs(args.index(&FullRange)), dest) } ast::ExprBinary(op, ref lhs, ref rhs) => { @@ -1211,7 +1211,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr.span, format!("trans_rvalue_dps_unadjusted reached fall-through \ case: {}", - expr.node)[]); + expr.node).index(&FullRange)); } } } @@ -1261,7 +1261,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.tcx().sess.span_bug(ref_expr.span, format!( "Non-DPS def {} referened by {}", - def, bcx.node_id_to_string(ref_expr.id))[]); + def, bcx.node_id_to_string(ref_expr.id)).index(&FullRange)); } } } @@ -1290,7 +1290,7 @@ pub fn trans_def_fn_unadjusted<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.tcx().sess.span_bug(ref_expr.span, format!( "trans_def_fn_unadjusted invoked on: {} for {}", def, - ref_expr.repr(ccx.tcx()))[]); + ref_expr.repr(ccx.tcx())).index(&FullRange)); } } } @@ -1310,7 +1310,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, None => { bcx.sess().bug(format!( "trans_local_var: no llval for upvar {} found", - nid)[]); + nid).index(&FullRange)); } } } @@ -1320,7 +1320,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, None => { bcx.sess().bug(format!( "trans_local_var: no datum for local/arg {} found", - nid)[]); + nid).index(&FullRange)); } }; debug!("take_local(nid={}, v={}, ty={})", @@ -1330,7 +1330,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => { bcx.sess().unimpl(format!( "unsupported def type in trans_local_var: {}", - def)[]); + def).index(&FullRange)); } } } @@ -1347,11 +1347,11 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, { match ty.sty { ty::ty_struct(did, substs) => { - op(0, struct_fields(tcx, did, substs)[]) + op(0, struct_fields(tcx, did, substs).index(&FullRange)) } ty::ty_tup(ref v) => { - op(0, tup_fields(v[])[]) + op(0, tup_fields(v.index(&FullRange)).index(&FullRange)) } ty::ty_enum(_, substs) => { @@ -1361,7 +1361,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, tcx.sess.bug(format!( "cannot get field types from the enum type {} \ without a node ID", - ty.repr(tcx))[]); + ty.repr(tcx)).index(&FullRange)); } Some(node_id) => { let def = tcx.def_map.borrow()[node_id].clone(); @@ -1372,7 +1372,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, op(variant_info.disr_val, struct_fields(tcx, variant_id, - substs)[]) + substs).index(&FullRange)) } _ => { tcx.sess.bug("resolve didn't map this expr to a \ @@ -1386,7 +1386,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, _ => { tcx.sess.bug(format!( "cannot get field types from the type {}", - ty.repr(tcx))[]); + ty.repr(tcx)).index(&FullRange)); } } } @@ -1441,7 +1441,7 @@ fn trans_struct<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_adt(bcx, ty, discr, - numbered_fields[], + numbered_fields.index(&FullRange), optbase, dest, Some(NodeInfo { id: expr_id, span: expr_span })) @@ -2078,7 +2078,7 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), - k_out)[]) + k_out).index(&FullRange)) } } } @@ -2087,7 +2087,7 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), - k_out)[]) + k_out).index(&FullRange)) }; return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock(); } @@ -2249,7 +2249,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.tcx().sess.span_bug( expr.span, format!("deref invoked on expr of illegal type {}", - datum.ty.repr(bcx.tcx()))[]); + datum.ty.repr(bcx.tcx())).index(&FullRange)); } }; diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 1c9be6ae4a8ba..a90f0dbbf151b 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -109,7 +109,7 @@ pub fn register_static(ccx: &CrateContext, let llty = type_of::type_of(ccx, ty); let ident = link_name(foreign_item); - match attr::first_attr_value_str_by_name(foreign_item.attrs[], + match attr::first_attr_value_str_by_name(foreign_item.attrs.index(&FullRange), "linkage") { // If this is a static with a linkage specified, then we need to handle // it a little specially. The typesystem prevents things like &T and @@ -233,13 +233,13 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, fn_ty.sig.clone()), _ => ccx.sess().bug("trans_native_call called on non-function type") }; - let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys[]); + let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys.index(&FullRange)); let fn_type = cabi::compute_abi_info(ccx, - llsig.llarg_tys[], + llsig.llarg_tys.index(&FullRange), llsig.llret_ty, llsig.ret_def); - let arg_tys: &[cabi::ArgType] = fn_type.arg_tys[]; + let arg_tys: &[cabi::ArgType] = fn_type.arg_tys.index(&FullRange); let mut llargs_foreign = Vec::new(); @@ -365,7 +365,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llforeign_retval = CallWithConv(bcx, llfn, - llargs_foreign[], + llargs_foreign.index(&FullRange), cc, Some(attrs)); @@ -435,7 +435,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { abi => { let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id); register_foreign_item_fn(ccx, abi, ty, - lname.get()[]); + lname.get().index(&FullRange)); // Unlike for other items, we shouldn't call // `base::update_linkage` here. Foreign items have // special linkage requirements, which are handled @@ -567,7 +567,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \ expected a bare fn ty", ccx.tcx().map.path_to_string(id), - t.repr(tcx))[]); + t.repr(tcx)).index(&FullRange)); } }; @@ -575,7 +575,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.tcx().map.path_to_string(id), id, t.repr(tcx)); - let llfn = base::decl_internal_rust_fn(ccx, t, ps[]); + let llfn = base::decl_internal_rust_fn(ccx, t, ps.index(&FullRange)); base::set_llvm_fn_attrs(ccx, attrs, llfn); base::trans_fn(ccx, decl, body, llfn, param_substs, id, &[]); llfn @@ -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[], Some(attributes)); + let llrust_ret_val = builder.call(llrustfn, llrust_args.index(&FullRange), Some(attributes)); // Get the return value where the foreign fn expects it. let llforeign_ret_ty = match tys.fn_ty.ret_ty.cast { @@ -815,9 +815,9 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // the massive simplifications that have occurred. pub fn link_name(i: &ast::ForeignItem) -> InternedString { - match attr::first_attr_value_str_by_name(i.attrs[], "link_name") { + match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "link_name") { Some(ln) => ln.clone(), - None => match weak_lang_items::link_name(i.attrs[]) { + None => match weak_lang_items::link_name(i.attrs.index(&FullRange)) { Some(name) => name, None => token::get_ident(i.ident), } @@ -858,7 +858,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }; let llsig = foreign_signature(ccx, &fn_sig, fn_sig.0.inputs.as_slice()); let fn_ty = cabi::compute_abi_info(ccx, - llsig.llarg_tys[], + llsig.llarg_tys.index(&FullRange), llsig.llret_ty, llsig.ret_def); debug!("foreign_types_for_fn_ty(\ @@ -867,9 +867,9 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty={} -> {}, \ ret_def={}", ty.repr(ccx.tcx()), - ccx.tn().types_to_str(llsig.llarg_tys[]), + 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::>()[]), + ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::>().index(&FullRange)), ccx.tn().type_to_string(fn_ty.ret_ty.ty), llsig.ret_def); @@ -919,7 +919,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T if tys.fn_sig.0.variadic { Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty) } else { - Type::func(llargument_tys[], &llreturn_ty) + Type::func(llargument_tys.index(&FullRange), &llreturn_ty) } } diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 2fd9031fdfe4c..056842657ad29 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -161,7 +161,7 @@ pub fn get_drop_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Val let (glue, new_sym) = match ccx.available_drop_glues().borrow().get(&t) { Some(old_sym) => { - let glue = decl_cdecl_fn(ccx, old_sym[], llfnty, ty::mk_nil(ccx.tcx())); + let glue = decl_cdecl_fn(ccx, old_sym.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx())); (glue, None) }, None => { @@ -232,7 +232,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, f.sig.0.inputs[0] } _ => bcx.sess().bug(format!("Expected function type, found {}", - bcx.ty_to_string(fty))[]) + bcx.ty_to_string(fty)).index(&FullRange)) }; let (struct_data, info) = if type_is_sized(bcx.tcx(), t) { @@ -293,7 +293,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, class_did, &[get_drop_glue_type(bcx.ccx(), t)], ty::mk_nil(bcx.tcx())); - let (_, variant_cx) = invoke(variant_cx, dtor_addr, args[], dtor_ty, None); + let (_, variant_cx) = invoke(variant_cx, dtor_addr, args.index(&FullRange), dtor_ty, None); variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope); variant_cx @@ -352,7 +352,7 @@ fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, info: (Mul(bcx, info, C_uint(bcx.ccx(), unit_size)), C_uint(bcx.ccx(), 8u)) } _ => bcx.sess().bug(format!("Unexpected unsized type, found {}", - bcx.ty_to_string(t))[]) + bcx.ty_to_string(t)).index(&FullRange)) } } @@ -424,7 +424,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: Ty<'tcx>) bcx.sess().warn(format!("Ignoring drop flag in destructor for {}\ because the struct is unsized. See issue\ #16758", - bcx.ty_to_string(t))[]); + bcx.ty_to_string(t)).index(&FullRange)); trans_struct_drop(bcx, t, v0, dtor, did, substs) } } @@ -494,7 +494,7 @@ pub fn declare_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) note_unique_llvm_symbol(ccx, name); let ty_name = token::intern_and_get_ident( - ppaux::ty_to_string(ccx.tcx(), t)[]); + ppaux::ty_to_string(ccx.tcx(), t).index(&FullRange)); let ty_name = C_str_slice(ccx, ty_name); debug!("--- declare_tydesc {}", ppaux::ty_to_string(ccx.tcx(), t)); @@ -513,8 +513,8 @@ fn declare_generic_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, let fn_nm = mangle_internal_name_by_type_and_seq( ccx, t, - format!("glue_{}", name)[]); - let llfn = decl_cdecl_fn(ccx, fn_nm[], llfnty, ty::mk_nil(ccx.tcx())); + format!("glue_{}", name).index(&FullRange)); + let llfn = decl_cdecl_fn(ccx, fn_nm.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx())); note_unique_llvm_symbol(ccx, fn_nm.clone()); return (fn_nm, llfn); } diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index f6d69959dadf9..53ce8dd64b87d 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -77,7 +77,7 @@ pub fn trans_impl(ccx: &CrateContext, match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_generics().ty_params.len() == 0u { - let trans_everywhere = attr::requests_inline(method.attrs[]); + let trans_everywhere = attr::requests_inline(method.attrs.index(&FullRange)); for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) { let llfn = get_item_val(ccx, method.id); trans_fn(ccx, @@ -229,7 +229,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Here, in this call, which I've written with explicit UFCS // notation, the set of type parameters will be: // - // rcvr_type: [] <-- nothing declared on the trait itself + // rcvr_type: .index(&FullRange) <-- nothing declared on the trait itself // rcvr_self: [Vec] <-- the self type // rcvr_method: [String] <-- method type parameter // @@ -268,11 +268,11 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // // Recall that we matched ` as Convert>`. Trait // resolution will have given us a substitution - // containing `impl_substs=[[T=int],[],[]]` (the type + // containing `impl_substs=[[T=int],.index(&FullRange),.index(&FullRange)]` (the type // parameters defined on the impl). We combine // that with the `rcvr_method` from before, which tells us // the type parameters from the *method*, to yield - // `callee_substs=[[T=int],[],[U=String]]`. + // `callee_substs=[[T=int],.index(&FullRange),[U=String]]`. let subst::SeparateVecsPerParamSpace { types: impl_type, selfs: impl_self, @@ -290,7 +290,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } _ => { tcx.sess.bug(format!("static call to invalid vtable: {}", - vtbl.repr(tcx))[]); + vtbl.repr(tcx)).index(&FullRange)); } } } @@ -378,7 +378,7 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, traits::VtableParam(..) => { bcx.sess().bug( format!("resolved vtable bad vtable {} in trans", - vtable.repr(bcx.tcx()))[]); + vtable.repr(bcx.tcx())).index(&FullRange)); } } } @@ -728,7 +728,7 @@ pub fn get_vtable<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.sess().bug( format!("resolved vtable for {} to bad vtable {} in trans", trait_ref.repr(bcx.tcx()), - vtable.repr(bcx.tcx()))[]); + vtable.repr(bcx.tcx())).index(&FullRange)); } } }); @@ -760,7 +760,7 @@ pub fn make_vtable>(ccx: &CrateContext, let components: Vec<_> = head.into_iter().chain(ptrs).collect(); unsafe { - let tbl = C_struct(ccx, components[], false); + let tbl = C_struct(ccx, components.index(&FullRange), false); let sym = token::gensym("vtable"); let buf = CString::from_vec(format!("vtable{}", sym.uint()).into_bytes()); let vt_gvar = llvm::LLVMAddGlobal(ccx.llmod(), val_ty(tbl).to_ref(), diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index e6db462a342da..df67866e5b025 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -131,7 +131,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, hash = format!("h{}", state.result()); ccx.tcx().map.with_path(fn_id.node, |path| { - exported_name(path, hash[]) + exported_name(path, hash.index(&FullRange)) }) }; @@ -141,9 +141,9 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let mut hash_id = Some(hash_id); let mut mk_lldecl = |&mut : abi: abi::Abi| { let lldecl = if abi != abi::Rust { - foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s[]) + foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s.index(&FullRange)) } else { - decl_internal_rust_fn(ccx, mono_ty, s[]) + decl_internal_rust_fn(ccx, mono_ty, s.index(&FullRange)) }; ccx.monomorphized().borrow_mut().insert(hash_id.take().unwrap(), lldecl); @@ -177,12 +177,12 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, .. } => { let d = mk_lldecl(abi); - let needs_body = setup_lldecl(d, i.attrs[]); + let needs_body = setup_lldecl(d, i.attrs.index(&FullRange)); if needs_body { if abi != abi::Rust { foreign::trans_rust_fn_with_foreign_abi( ccx, &**decl, &**body, &[], d, psubsts, fn_id.node, - Some(hash[])); + Some(hash.index(&FullRange))); } else { trans_fn(ccx, &**decl, &**body, d, psubsts, fn_id.node, &[]); } @@ -206,7 +206,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, trans_enum_variant(ccx, parent, &*v, - args[], + args.index(&FullRange), this_tv.disr_val, psubsts, d); @@ -220,7 +220,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match *ii { ast::MethodImplItem(ref mth) => { let d = mk_lldecl(abi::Rust); - let needs_body = setup_lldecl(d, mth.attrs[]); + let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange)); if needs_body { trans_fn(ccx, mth.pe_fn_decl(), @@ -241,7 +241,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match *method { ast::ProvidedMethod(ref mth) => { let d = mk_lldecl(abi::Rust); - let needs_body = setup_lldecl(d, mth.attrs[]); + let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange)); if needs_body { trans_fn(ccx, mth.pe_fn_decl(), mth.pe_body(), d, psubsts, mth.id, &[]); @@ -250,7 +250,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } _ => { ccx.sess().bug(format!("can't monomorphize a {}", - map_node)[]) + map_node).index(&FullRange)) } } } @@ -258,7 +258,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let d = mk_lldecl(abi::Rust); set_inline_hint(d); base::trans_tuple_struct(ccx, - struct_def.fields[], + struct_def.fields.index(&FullRange), struct_def.ctor_id.expect("ast-mapped tuple struct \ didn't have a ctor id"), psubsts, @@ -276,7 +276,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ast_map::NodePat(..) | ast_map::NodeLocal(..) => { ccx.sess().bug(format!("can't monomorphize a {}", - map_node)[]) + map_node).index(&FullRange)) } }; diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs index 3785c2fb9bc54..a4f51bc50e567 100644 --- a/src/librustc_trans/trans/type_.rs +++ b/src/librustc_trans/trans/type_.rs @@ -103,7 +103,7 @@ impl Type { } pub fn int(ccx: &CrateContext) -> Type { - match ccx.tcx().sess.target.target.target_word_size[] { + match ccx.tcx().sess.target.target.target_word_size.index(&FullRange) { "32" => Type::i32(ccx), "64" => Type::i64(ccx), tws => panic!("Unsupported target word size for int: {}", tws), diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 3e499ea8498fb..c6c2749f37834 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -137,7 +137,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty)); atys.extend(input_tys); - Type::func(atys[], &lloutputtype) + Type::func(atys.index(&FullRange), &lloutputtype) } // Given a function type and a count of ty params, construct an llvm type @@ -182,7 +182,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ let llsizingty = match t.sty { _ if !lltype_is_sized(cx.tcx(), t) => { cx.sess().bug(format!("trying to take the sizing type of {}, an unsized type", - ppaux::ty_to_string(cx.tcx(), t))[]) + ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange)) } ty::ty_bool => Type::bool(cx), @@ -235,7 +235,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ ty::ty_projection(..) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => { cx.sess().bug(format!("fictitious type {} in sizing_type_of()", - ppaux::ty_to_string(cx.tcx(), t))[]) + ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange)) } ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => panic!("unreachable") }; @@ -312,7 +312,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { let repr = adt::represent_type(cx, t); let tps = substs.types.get_slice(subst::TypeSpace); let name = llvm_type_name(cx, an_enum, did, tps); - adt::incomplete_type_of(cx, &*repr, name[]) + adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) } ty::ty_unboxed_closure(did, _, ref substs) => { // Only create the named struct, but don't fill it in. We @@ -323,7 +323,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // contents of the VecPerParamSpace to to construct the llvm // name let name = llvm_type_name(cx, an_unboxed_closure, did, substs.types.as_slice()); - adt::incomplete_type_of(cx, &*repr, name[]) + adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) } ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => { @@ -379,7 +379,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { let repr = adt::represent_type(cx, t); let tps = substs.types.get_slice(subst::TypeSpace); let name = llvm_type_name(cx, a_struct, did, tps); - adt::incomplete_type_of(cx, &*repr, name[]) + adt::incomplete_type_of(cx, &*repr, name.index(&FullRange)) } } @@ -398,7 +398,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { } ty::ty_trait(..) => Type::opaque_trait(cx), _ => cx.sess().bug(format!("ty_open with sized type: {}", - ppaux::ty_to_string(cx.tcx(), t))[]) + ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange)) }, ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"), diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 183b8c5c830ef..7d36d01cc5060 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -197,7 +197,7 @@ pub fn opt_ast_region_to_region<'tcx>( help_name } else { format!("one of {}'s {} elided lifetimes", help_name, n) - }[]); + }.index(&FullRange)); if len == 2 && i == 0 { m.push_str(" or "); @@ -347,7 +347,7 @@ fn create_substs_for_ast_path<'tcx>( format!("wrong number of type arguments: {} {}, found {}", expected, required_ty_param_count, - supplied_ty_param_count)[]); + supplied_ty_param_count).index(&FullRange)); } else if supplied_ty_param_count > formal_ty_param_count { let expected = if required_ty_param_count < formal_ty_param_count { "expected at most" @@ -358,7 +358,7 @@ fn create_substs_for_ast_path<'tcx>( format!("wrong number of type arguments: {} {}, found {}", expected, formal_ty_param_count, - supplied_ty_param_count)[]); + supplied_ty_param_count).index(&FullRange)); } let mut substs = Substs::new_type(types, regions); @@ -377,7 +377,7 @@ fn create_substs_for_ast_path<'tcx>( } } - for param in ty_param_defs[supplied_ty_param_count..].iter() { + for param in ty_param_defs.index(&(supplied_ty_param_count..)).iter() { match param.default { Some(default) => { // This is a default type parameter. @@ -556,7 +556,7 @@ pub fn instantiate_trait_ref<'tcx>( _ => { this.tcx().sess.span_fatal( ast_trait_ref.path.span, - format!("`{}` is not a trait", ast_trait_ref.path.user_string(this.tcx()))[]); + format!("`{}` is not a trait", ast_trait_ref.path.user_string(this.tcx())).index(&FullRange)); } } } @@ -825,7 +825,7 @@ pub fn ast_ty_to_builtin_ty<'tcx>( .sess .span_bug(ast_ty.span, format!("unbound path {}", - path.repr(this.tcx()))[]) + path.repr(this.tcx())).index(&FullRange)) } Some(&d) => d }; @@ -847,7 +847,7 @@ pub fn ast_ty_to_builtin_ty<'tcx>( this.tcx().sess.span_bug( path.span, format!("converting `Box` to `{}`", - ty.repr(this.tcx()))[]); + ty.repr(this.tcx())).index(&FullRange)); } } } @@ -1067,10 +1067,10 @@ pub fn ast_ty_to_ty<'tcx>( ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty), None) } ast::TyObjectSum(ref ty, ref bounds) => { - match ast_ty_to_trait_ref(this, rscope, &**ty, 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[]) + trait_ref, projection_bounds, bounds.index(&FullRange)) } Err(ErrorReported) => { this.tcx().types.err @@ -1105,7 +1105,7 @@ pub fn ast_ty_to_ty<'tcx>( ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(bare_fn)) } ast::TyPolyTraitRef(ref bounds) => { - conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds[]) + conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds.index(&FullRange)) } ast::TyPath(ref path, id) => { let a_def = match tcx.def_map.borrow().get(&id) { @@ -1113,7 +1113,7 @@ pub fn ast_ty_to_ty<'tcx>( tcx.sess .span_bug(ast_ty.span, format!("unbound path {}", - path.repr(tcx))[]) + path.repr(tcx)).index(&FullRange)) } Some(&d) => d }; @@ -1152,7 +1152,7 @@ pub fn ast_ty_to_ty<'tcx>( def::DefMod(id) => { tcx.sess.span_fatal(ast_ty.span, format!("found module name used as a type: {}", - tcx.map.node_to_string(id.node))[]); + tcx.map.node_to_string(id.node)).index(&FullRange)); } def::DefPrimTy(_) => { panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call"); @@ -1171,7 +1171,7 @@ pub fn ast_ty_to_ty<'tcx>( .last() .unwrap() .identifier) - .get())[]); + .get()).index(&FullRange)); this.tcx().types.err } def::DefAssociatedPath(provenance, assoc_ident) => { @@ -1181,7 +1181,7 @@ pub fn ast_ty_to_ty<'tcx>( tcx.sess.span_fatal(ast_ty.span, format!("found value name used \ as a type: {}", - a_def)[]); + a_def).index(&FullRange)); } } } @@ -1209,7 +1209,7 @@ pub fn ast_ty_to_ty<'tcx>( ast_ty.span, format!("expected constant expr for array \ length: {}", - *r)[]); + *r).index(&FullRange)); } } } @@ -1331,7 +1331,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx>, let input_params = if self_ty.is_some() { decl.inputs.slice_from(1) } else { - decl.inputs[] + decl.inputs.index(&FullRange) }; let input_tys = input_params.iter().map(|a| ty_of_arg(this, &rb, a, None)); let input_pats: Vec = input_params.iter() @@ -1546,7 +1546,7 @@ fn conv_ty_poly_trait_ref<'tcx>( ast_bounds: &[ast::TyParamBound]) -> Ty<'tcx> { - let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds[]); + let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds.index(&FullRange)); let mut projection_bounds = Vec::new(); let main_trait_bound = if !partitioned_bounds.trait_bounds.is_empty() { @@ -1596,7 +1596,7 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( this.tcx().sess.span_err( b.trait_ref.path.span, format!("only the builtin traits can be used \ - as closure or object bounds")[]); + as closure or object bounds").index(&FullRange)); } let region_bound = compute_region_bound(this, @@ -1669,7 +1669,7 @@ fn compute_opt_region_bound<'tcx>(tcx: &ty::ctxt<'tcx>, tcx.sess.span_err( span, format!("ambiguous lifetime bound, \ - explicit lifetime bound required")[]); + explicit lifetime bound required").index(&FullRange)); } return Some(r); } @@ -1695,7 +1695,7 @@ fn compute_region_bound<'tcx>( None => { this.tcx().sess.span_err( span, - format!("explicit lifetime bound required")[]); + format!("explicit lifetime bound required").index(&FullRange)); ty::ReStatic } } diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index adea5084aab2b..a9018c8985a2f 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -315,7 +315,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { self.tcx().sess.span_bug( self.span, format!("self-type `{}` for ObjectPick never dereferenced to an object", - self_ty.repr(self.tcx()))[]) + self_ty.repr(self.tcx())).index(&FullRange)) } } } @@ -370,7 +370,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { format!( "{} was a subtype of {} but now is not?", self_ty.repr(self.tcx()), - method_self_ty.repr(self.tcx()))[]); + method_self_ty.repr(self.tcx())).index(&FullRange)); } } } diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index ad43dd84ef6b2..f495885bd108d 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -266,7 +266,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, span, format!( "trait method is &self but first arg is: {}", - transformed_self_ty.repr(fcx.tcx()))[]); + transformed_self_ty.repr(fcx.tcx())).index(&FullRange)); } } } @@ -276,7 +276,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, span, format!( "unexpected explicit self type in operator method: {}", - method_ty.explicit_self)[]); + method_ty.explicit_self).index(&FullRange)); } } } @@ -330,7 +330,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, if is_field { cx.sess.span_note(span, format!("use `(s.{0})(...)` if you meant to call the \ - function stored in the `{0}` field", method_ustring)[]); + function stored in the `{0}` field", method_ustring).index(&FullRange)); } if static_sources.len() > 0 { diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 115711ae92b29..3bc29bb9ef737 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -576,7 +576,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { self.tcx().sess.span_bug( self.span, format!("No entry for unboxed closure: {}", - closure_def_id.repr(self.tcx()))[]); + closure_def_id.repr(self.tcx())).index(&FullRange)); } }; @@ -745,7 +745,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("pick_method(self_ty={})", self.infcx().ty_to_string(self_ty)); debug!("searching inherent candidates"); - match self.consider_candidates(self_ty, self.inherent_candidates[]) { + match self.consider_candidates(self_ty, self.inherent_candidates.index(&FullRange)) { None => {} Some(pick) => { return Some(pick); @@ -753,7 +753,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { } debug!("searching extension candidates"); - self.consider_candidates(self_ty, self.extension_candidates[]) + self.consider_candidates(self_ty, self.extension_candidates.index(&FullRange)) } fn consider_candidates(&self, @@ -768,7 +768,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("applicable_candidates: {}", applicable_candidates.repr(self.tcx())); if applicable_candidates.len() > 1 { - match self.collapse_candidates_to_trait_pick(applicable_candidates[]) { + match self.collapse_candidates_to_trait_pick(applicable_candidates.index(&FullRange)) { Some(pick) => { return Some(Ok(pick)); } None => { } } @@ -864,7 +864,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { Some(data) => data, None => return None, }; - if probes[1..].iter().any(|p| p.to_trait_data() != Some(trait_data)) { + if probes.index(&(1..)).iter().any(|p| p.to_trait_data() != Some(trait_data)) { return None; } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1b51434a58cc1..25e53c74f2572 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -593,7 +593,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>, let tcx = ccx.tcx; let err_count_on_creation = tcx.sess.err_count(); - let arg_tys = fn_sig.inputs[]; + let arg_tys = fn_sig.inputs.index(&FullRange); let ret_ty = fn_sig.output; debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})", @@ -691,7 +691,7 @@ pub fn check_item(ccx: &CrateCtxt, it: &ast::Item) { ast::ItemEnum(ref enum_definition, _) => { check_enum_variants(ccx, it.span, - enum_definition.variants[], + enum_definition.variants.index(&FullRange), it.id); } ast::ItemFn(ref decl, _, _, _, ref body) => { @@ -989,7 +989,7 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, but not in the trait", token::get_name(trait_m.name), ppaux::explicit_self_category_to_str( - &impl_m.explicit_self))[]); + &impl_m.explicit_self)).index(&FullRange)); return; } (_, &ty::StaticExplicitSelfCategory) => { @@ -999,7 +999,7 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, but not in the impl", token::get_name(trait_m.name), ppaux::explicit_self_category_to_str( - &trait_m.explicit_self))[]); + &trait_m.explicit_self)).index(&FullRange)); return; } _ => { @@ -1360,7 +1360,7 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, span, format!("lifetime parameters or bounds on method `{}` do \ not match the trait declaration", - token::get_name(impl_m.name))[]); + token::get_name(impl_m.name)).index(&FullRange)); return false; } @@ -1412,7 +1412,7 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, from its counterpart `{}` \ declared in the trait", impl_param.name.user_string(tcx), - trait_param.name.user_string(tcx))[]); + trait_param.name.user_string(tcx)).index(&FullRange)); true } else { false @@ -1422,14 +1422,14 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, tcx.sess.span_note( span, format!("the impl is missing the following bounds: `{}`", - missing.user_string(tcx))[]); + missing.user_string(tcx)).index(&FullRange)); } if extra.len() != 0 { tcx.sess.span_note( span, format!("the impl has the following extra bounds: `{}`", - extra.user_string(tcx))[]); + extra.user_string(tcx)).index(&FullRange)); } if err { @@ -1700,7 +1700,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.tcx().sess.span_bug( span, format!("no type for local variable {}", - nid)[]); + nid).index(&FullRange)); } } } @@ -2034,7 +2034,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { Some(&t) => t, None => { self.tcx().sess.bug(format!("no type for expr in fcx {}", - self.tag())[]); + self.tag()).index(&FullRange)); } } } @@ -2064,7 +2064,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.tcx().sess.bug( format!("no type for node {}: {} in fcx {}", id, self.tcx().map.node_to_string(id), - self.tag())[]); + self.tag()).index(&FullRange)); } } } @@ -2544,7 +2544,7 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, Ok(trait_did) => trait_did, Err(ref err_string) => { fcx.tcx().sess.span_err(iterator_expr.span, - err_string[]); + err_string.index(&FullRange)); return fcx.tcx().types.err } }; @@ -2571,7 +2571,7 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, format!("`for` loop expression has type `{}` which does \ not implement the `Iterator` trait; \ maybe try .iter()", - ty_string)[]); + ty_string).index(&FullRange)); } fcx.tcx().types.err } @@ -2609,7 +2609,7 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, format!("`next` method of the `Iterator` \ trait has an unexpected type `{}`", fcx.infcx().ty_to_string(return_type)) - []); + .index(&FullRange)); fcx.tcx().types.err } } @@ -2636,7 +2636,7 @@ fn check_method_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, check_argument_types(fcx, sp, - err_inputs[], + err_inputs.index(&FullRange), args_no_rcvr, autoref_args, false, @@ -3088,7 +3088,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, }; // Call the generic checker. - let args: Vec<_> = args[1..].iter().map(|x| x).collect(); + let args: Vec<_> = args.index(&(1..)).iter().map(|x| x).collect(); let ret_ty = check_method_argument_types(fcx, method_name.span, fn_ty, @@ -3406,7 +3406,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty::ty_struct(base_id, substs) => { debug!("struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_field_ty(tcx, base_id, fields[], + lookup_field_ty(tcx, base_id, fields.index(&FullRange), field.node.name, &(*substs)) } _ => None @@ -3469,7 +3469,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, if tuple_like { debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_tup_field_ty(tcx, base_id, fields[], + lookup_tup_field_ty(tcx, base_id, fields.index(&FullRange), idx.node, &(*substs)) } else { None @@ -3634,7 +3634,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, class_id, id, fcx.ccx.tcx.mk_substs(struct_substs), - class_fields[], + class_fields.index(&FullRange), fields, base_expr.is_none(), None); @@ -3677,7 +3677,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, variant_id, id, fcx.ccx.tcx.mk_substs(substitutions), - variant_fields[], + variant_fields.index(&FullRange), fields, true, Some(enum_id)); @@ -4056,7 +4056,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[], tps[], lvalue_pref); + check_method_call(fcx, expr, ident, args.index(&FullRange), tps.index(&FullRange), lvalue_pref); let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); let args_err = arg_tys.fold(false, |rest_err, a| { @@ -4144,7 +4144,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let expected = expected.only_has_type(); let flds = expected.map_to_option(fcx, |ty| { match ty.sty { - ty::ty_tup(ref flds) => Some(flds[]), + ty::ty_tup(ref flds) => Some(flds.index(&FullRange)), _ => None } }); @@ -4178,7 +4178,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let struct_id = match def { Some(def::DefVariant(enum_id, variant_id, true)) => { check_struct_enum_variant(fcx, id, expr.span, enum_id, - variant_id, fields[]); + variant_id, fields.index(&FullRange)); enum_id } Some(def::DefTrait(def_id)) => { @@ -4187,7 +4187,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, pprust::path_to_string(path)); check_struct_fields_on_error(fcx, id, - fields[], + fields.index(&FullRange), base_expr); def_id }, @@ -4200,7 +4200,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, id, expr.span, struct_did, - fields[], + fields.index(&FullRange), base_expr.as_ref().map(|e| &**e)); } _ => { @@ -4209,7 +4209,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, pprust::path_to_string(path)); check_struct_fields_on_error(fcx, id, - fields[], + fields.index(&FullRange), base_expr); } } @@ -4250,7 +4250,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, fcx.infcx() .ty_to_string( actual_structure_type), - type_error_description)[]); + type_error_description).index(&FullRange)); ty::note_and_explain_type_err(tcx, &type_error); } } @@ -4971,7 +4971,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt, } let hint = *ty::lookup_repr_hints(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id }) - [].get(0).unwrap_or(&attr::ReprAny); + .index(&FullRange).get(0).unwrap_or(&attr::ReprAny); if hint != attr::ReprAny && vs.len() <= 1 { if vs.len() == 1 { @@ -5642,7 +5642,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "get_tydesc" => { let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) { Ok(t) => t, - Err(s) => { tcx.sess.span_fatal(it.span, s[]); } + Err(s) => { tcx.sess.span_fatal(it.span, s.index(&FullRange)); } }; let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt { ty: tydesc_ty, @@ -5658,7 +5658,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { ty::mk_struct(ccx.tcx, did, ccx.tcx.mk_substs(subst::Substs::empty()))), Err(msg) => { - tcx.sess.span_fatal(it.span, msg[]); + tcx.sess.span_fatal(it.span, msg.index(&FullRange)); } } }, diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index c7df5ed8453fd..ffb721dd7ac7d 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -189,7 +189,7 @@ fn region_of_def(fcx: &FnCtxt, def: def::Def) -> ty::Region { } _ => { tcx.sess.bug(format!("unexpected def in region_of_def: {}", - def)[]) + def).index(&FullRange)) } } } @@ -282,13 +282,13 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { Some(f) => f, None => { self.tcx().sess.bug( - format!("No fn-sig entry for id={}", id)[]); + format!("No fn-sig entry for id={}", id).index(&FullRange)); } }; let len = self.region_bound_pairs.len(); - self.relate_free_regions(fn_sig[], body.id); - link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs[]); + self.relate_free_regions(fn_sig.index(&FullRange), body.id); + link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs.index(&FullRange)); self.visit_block(body); self.visit_region_obligations(body.id); self.region_bound_pairs.truncate(len); @@ -627,7 +627,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { } ast::ExprMatch(ref discr, ref arms, _) => { - link_match(rcx, &**discr, arms[]); + link_match(rcx, &**discr, arms.index(&FullRange)); visit::walk_expr(rcx, expr); } @@ -952,7 +952,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => rcx.tcx().sess.span_bug(deref_expr.span, format!("bad overloaded deref type {}", - method.ty.repr(rcx.tcx()))[]) + method.ty.repr(rcx.tcx())).index(&FullRange)) }; { let mc = mc::MemCategorizationContext::new(rcx.fcx); @@ -1318,7 +1318,7 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, span, format!("Illegal upvar id: {}", upvar_id.repr( - rcx.tcx()))[]); + rcx.tcx())).index(&FullRange)); } } } diff --git a/src/librustc_typeck/check/regionmanip.rs b/src/librustc_typeck/check/regionmanip.rs index 7ca21bdf5b83f..84d94b0392e9d 100644 --- a/src/librustc_typeck/check/regionmanip.rs +++ b/src/librustc_typeck/check/regionmanip.rs @@ -147,7 +147,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { ty::ty_open(_) => { self.tcx.sess.bug( format!("Unexpected type encountered while doing wf check: {}", - ty.repr(self.tcx))[]); + ty.repr(self.tcx)).index(&FullRange)); } } } diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index 87ede24226bdb..e302609bf228b 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -74,7 +74,7 @@ pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, source_expr.span, format!("can only cast an boxed pointer \ to a boxed object, not a {}", - ty::ty_sort_string(fcx.tcx(), source_ty))[]); + ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange)); } (_, &ty::ty_rptr(..)) => { @@ -82,7 +82,7 @@ pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, source_expr.span, format!("can only cast a &-pointer \ to an &-object, not a {}", - ty::ty_sort_string(fcx.tcx(), source_ty))[]); + ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange)); } _ => { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 09ab98745bd6a..7597a410f62bf 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -81,7 +81,7 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, inference_context.tcx.sess.span_bug( span, format!("coherence encountered unexpected type searching for base type: {}", - ty.repr(inference_context.tcx))[]); + ty.repr(inference_context.tcx)).index(&FullRange)); } } } @@ -490,7 +490,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { format!("the trait `Copy` may not be \ implemented for this type; field \ `{}` does not implement `Copy`", - token::get_name(name))[]) + token::get_name(name)).index(&FullRange)) } Err(ty::VariantDoesNotImplementCopy(name)) => { tcx.sess @@ -498,7 +498,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { format!("the trait `Copy` may not be \ implemented for this type; variant \ `{}` does not implement `Copy`", - token::get_name(name))[]) + token::get_name(name)).index(&FullRange)) } Err(ty::TypeIsStructural) => { tcx.sess diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index bbafcdae1bba1..cc36065656cb3 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -211,7 +211,7 @@ fn get_enum_variant_types<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ast::TupleVariantKind(ref args) if args.len() > 0 => { let rs = ExplicitRscope; let input_tys: Vec<_> = args.iter().map(|va| ccx.to_ty(&rs, &*va.ty)).collect(); - ty::mk_ctor_fn(tcx, variant_def_id, input_tys[], enum_ty) + ty::mk_ctor_fn(tcx, variant_def_id, input_tys.index(&FullRange), enum_ty) } ast::TupleVariantKind(_) => { @@ -258,7 +258,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ccx, trait_id, &trait_def.generics, - trait_items[], + trait_items.index(&FullRange), &m.id, &m.ident.name, &m.explicit_self, @@ -272,7 +272,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ccx, trait_id, &trait_def.generics, - trait_items[], + trait_items.index(&FullRange), &m.id, &m.pe_ident().name, m.pe_explicit_self(), @@ -774,7 +774,7 @@ fn convert_struct<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, local_def(field.node.id)].ty).collect(); let ctor_fn_ty = ty::mk_ctor_fn(tcx, local_def(ctor_id), - inputs[], + inputs.index(&FullRange), selfty); write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty); tcx.tcache.borrow_mut().insert(local_def(ctor_id), @@ -815,7 +815,7 @@ fn get_trait_def<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ast_map::NodeItem(item) => trait_def_of_item(ccx, &*item), _ => { ccx.tcx.sess.bug(format!("get_trait_def({}): not an item", - trait_id.node)[]) + trait_id.node).index(&FullRange)) } } } @@ -840,7 +840,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ref s => { tcx.sess.span_bug( it.span, - format!("trait_def_of_item invoked on {}", s)[]); + format!("trait_def_of_item invoked on {}", s).index(&FullRange)); } }; @@ -1025,8 +1025,8 @@ fn ty_generics_for_type_or_impl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, -> ty::Generics<'tcx> { ty_generics(ccx, subst::TypeSpace, - generics.lifetimes[], - generics.ty_params[], + generics.lifetimes.index(&FullRange), + generics.ty_params.index(&FullRange), ty::Generics::empty(), &generics.where_clause) } @@ -1044,8 +1044,8 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, let mut generics = ty_generics(ccx, subst::TypeSpace, - ast_generics.lifetimes[], - ast_generics.ty_params[], + ast_generics.lifetimes.index(&FullRange), + ast_generics.ty_params.index(&FullRange), ty::Generics::empty(), &ast_generics.where_clause); @@ -1130,8 +1130,8 @@ fn ty_generics_for_fn_or_method<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, let early_lifetimes = resolve_lifetime::early_bound_lifetimes(generics); ty_generics(ccx, subst::FnSpace, - early_lifetimes[], - generics.ty_params[], + early_lifetimes.index(&FullRange), + generics.ty_params.index(&FullRange), base_generics, &generics.where_clause) } @@ -1318,7 +1318,7 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, let param_ty = ty::ParamTy::new(space, index, param.ident.name); let bounds = compute_bounds(ccx, param_ty.to_ty(ccx.tcx), - param.bounds[], + param.bounds.index(&FullRange, SizedByDefault::Yes, param.span); let default = match param.default { @@ -1399,7 +1399,7 @@ fn check_bounds_compatible<'tcx>(tcx: &ty::ctxt<'tcx>, if !param_bounds.builtin_bounds.contains(&ty::BoundSized) { ty::each_bound_trait_and_supertraits( tcx, - param_bounds.trait_bounds[], + param_bounds.trait_bounds.index(&FullRange), |trait_ref| { let trait_def = ty::lookup_trait_def(tcx, trait_ref.def_id()); if trait_def.bounds.builtin_bounds.contains(&ty::BoundSized) { diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index dc434f1401585..f7abd8a1cc6a6 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -207,7 +207,7 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>, format!("{}: {}", msg(), ty::type_err_to_str(tcx, - terr))[]); + terr)).index(&FullRange)); ty::note_and_explain_type_err(tcx, terr); false } @@ -256,7 +256,7 @@ fn check_main_fn_ty(ccx: &CrateCtxt, format!("main has a non-function type: found \ `{}`", ppaux::ty_to_string(tcx, - main_t))[]); + main_t)).index(&FullRange)); } } } @@ -307,7 +307,7 @@ fn check_start_fn_ty(ccx: &CrateCtxt, tcx.sess.span_bug(start_span, format!("start has a non-function type: found \ `{}`", - ppaux::ty_to_string(tcx, start_t))[]); + ppaux::ty_to_string(tcx, start_t)).index(&FullRange)); } } } diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index e58c2275fcd96..3ca0e40c51ed4 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -564,7 +564,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { None => { self.tcx().sess.bug(format!( "no inferred index entry for {}", - self.tcx().map.node_to_string(param_id))[]); + self.tcx().map.node_to_string(param_id)).index(&FullRange)); } } } @@ -839,7 +839,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.tcx().sess.bug( format!("unexpected type encountered in \ variance inference: {}", - ty.repr(self.tcx()))[]); + ty.repr(self.tcx())).index(&FullRange)); } } } @@ -919,7 +919,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { .sess .bug(format!("unexpected region encountered in variance \ inference: {}", - region.repr(self.tcx()))[]); + region.repr(self.tcx())).index(&FullRange)); } } } @@ -1055,7 +1055,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { // attribute and report an error with various results if found. if ty::has_attr(tcx, item_def_id, "rustc_variance") { let found = item_variances.repr(tcx); - tcx.sess.span_err(tcx.map.span(item_id), found[]); + tcx.sess.span_err(tcx.map.span(item_id), found.index(&FullRange)); } let newly_added = tcx.item_variance_map.borrow_mut() diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bb9a9ac430340..e6d1dfd62d0fa 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -798,7 +798,7 @@ impl Clean for ast::Method { let all_inputs = &self.pe_fn_decl().inputs; let inputs = match self.pe_explicit_self().node { ast::SelfStatic => all_inputs.as_slice(), - _ => all_inputs[1..] + _ => all_inputs.index(&(1..)) }; let decl = FnDecl { inputs: Arguments { @@ -836,7 +836,7 @@ impl Clean for ast::TypeMethod { fn clean(&self, cx: &DocContext) -> Item { let inputs = match self.explicit_self.node { ast::SelfStatic => self.decl.inputs.as_slice(), - _ => self.decl.inputs[1..] + _ => self.decl.inputs.index(&(1..)) }; let decl = FnDecl { inputs: Arguments { @@ -1132,7 +1132,7 @@ impl<'tcx> Clean for ty::Method<'tcx> { self.fty.sig.clone()), s => { let sig = ty::Binder(ty::FnSig { - inputs: self.fty.sig.0.inputs[1..].to_vec(), + inputs: self.fty.sig.0.inputs.index(&(1..)).to_vec(), ..self.fty.sig.0.clone() }); let s = match s { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 9004d11b5bccf..6c0f6610802b4 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -311,7 +311,7 @@ fn path(w: &mut fmt::Formatter, match rel_root { Some(root) => { let mut root = String::from_str(root.as_slice()); - for seg in path.segments[..amt].iter() { + for seg in path.segments.index(&(0..amt)).iter() { if "super" == seg.name || "self" == seg.name { try!(write!(w, "{}::", seg.name)); @@ -326,7 +326,7 @@ fn path(w: &mut fmt::Formatter, } } None => { - for seg in path.segments[..amt].iter() { + for seg in path.segments.index(&(0..amt)).iter() { try!(write!(w, "{}::", seg.name)); } } diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 30b9d6c63c5bb..3d2c5e2cbb5fb 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -34,7 +34,7 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String { class, id, &mut out).unwrap(); - String::from_utf8_lossy(out[]).into_owned() + String::from_utf8_lossy(out.index(&FullRange)).into_owned() } /// Exhausts the `lexer` writing the output into `out`. diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 8b0fb75b438fe..18c79fb9c5982 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -193,7 +193,6 @@ //! ``` use self::JsonEvent::*; -use self::StackElement::*; use self::ErrorCode::*; use self::ParserError::*; use self::DecoderError::*; @@ -208,7 +207,7 @@ use std::num::{Float, Int}; use std::num::FpCategory as Fp; use std::str::FromStr; use std::string; -use std::ops; +use std::ops::Index; use unicode::str as unicode_str; use unicode::str::Utf16Item; @@ -384,7 +383,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { }; if start < i { - try!(wr.write_str(v[start..i])); + try!(wr.write_str(v.index(&(start..i)))); } try!(wr.write_str(escaped)); @@ -393,7 +392,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { } if start != v.len() { - try!(wr.write_str(v[start..])); + try!(wr.write_str(v.index(&(start..)))); } wr.write_str("\"") @@ -402,7 +401,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result { fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result { let mut buf = [0; 4]; let n = v.encode_utf8(&mut buf).unwrap(); - let buf = unsafe { str::from_utf8_unchecked(buf[0..n]) }; + let buf = unsafe { str::from_utf8_unchecked(buf.index(&(0..n))) }; escape_str(writer, buf) } @@ -415,7 +414,7 @@ fn spaces(wr: &mut fmt::Writer, mut n: uint) -> fmt::Result { } if n > 0 { - wr.write_str(BUF[..n]) + wr.write_str(BUF.index(&(0..n))) } else { Ok(()) } @@ -624,7 +623,7 @@ impl<'a> ::Encoder for Encoder<'a> { let mut check_encoder = Encoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf[]).unwrap(); + let out = str::from_utf8(buf.index(&FullRange)).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -895,7 +894,7 @@ impl<'a> ::Encoder for PrettyEncoder<'a> { let mut check_encoder = PrettyEncoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf[]).unwrap(); + let out = str::from_utf8(buf.index(&FullRange)).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -1028,7 +1027,7 @@ impl Json { /// Returns None otherwise. pub fn as_string<'a>(&'a self) -> Option<&'a str> { match *self { - Json::String(ref s) => Some(s[]), + Json::String(ref s) => Some(s.index(&FullRange)), _ => None } } @@ -1187,7 +1186,7 @@ pub struct Stack { } /// StackElements compose a Stack. -/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the +/// For example, StackElement::Key("foo"), StackElement::Key("bar"), StackElement::Index(3) and StackElement::Key("x") are the /// StackElements compositing the stack that represents foo.bar[3].x #[derive(PartialEq, Clone, Show)] pub enum StackElement<'l> { @@ -1219,10 +1218,11 @@ impl Stack { /// at the top. pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> { match self.stack[idx] { - InternalIndex(i) => Index(i), + InternalIndex(i) => StackElement::Index(i), InternalKey(start, size) => { - Key(str::from_utf8( - self.str_buffer[start as uint .. start as uint + size as uint]).unwrap()) + StackElement::Key(str::from_utf8( + self.str_buffer.index(&((start as uint) .. (start as uint + size as uint)))) + .unwrap()) } } } @@ -1261,16 +1261,16 @@ impl Stack { pub fn top<'l>(&'l self) -> Option> { return match self.stack.last() { None => None, - Some(&InternalIndex(i)) => Some(Index(i)), + Some(&InternalIndex(i)) => Some(StackElement::Index(i)), Some(&InternalKey(start, size)) => { - Some(Key(str::from_utf8( - self.str_buffer[start as uint .. (start+size) as uint] + Some(StackElement::Key(str::from_utf8( + self.str_buffer.index(&((start as uint) .. (start+size) as uint)) ).unwrap())) } } } - // Used by Parser to insert Key elements at the top of the stack. + // Used by Parser to insert StackElement::Key elements at the top of the stack. fn push_key(&mut self, key: string::String) { self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16)); for c in key.as_bytes().iter() { @@ -1278,7 +1278,7 @@ impl Stack { } } - // Used by Parser to insert Index elements at the top of the stack. + // Used by Parser to insert StackElement::Index elements at the top of the stack. fn push_index(&mut self, index: u32) { self.stack.push(InternalIndex(index)); } @@ -1948,7 +1948,7 @@ impl> Builder { _ => {} } let key = match self.parser.stack().top() { - Some(Key(k)) => { k.to_string() } + Some(StackElement::Key(k)) => { k.to_string() } _ => { panic!("invalid state"); } }; match self.build_value() { @@ -2143,7 +2143,7 @@ impl ::Decoder for Decoder { return Err(ExpectedError("String or Object".to_string(), format!("{}", json))) } }; - let idx = match names.iter().position(|n| *n == name[]) { + let idx = match names.iter().position(|n| *n == name.index(&FullRange)) { Some(idx) => idx, None => return Err(UnknownVariantError(name)) }; @@ -3351,7 +3351,7 @@ mod tests { hm.insert(1, true); let mut mem_buf = Vec::new(); write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(mem_buf[]).unwrap(); + let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -3367,7 +3367,7 @@ mod tests { hm.insert(1, true); let mut mem_buf = Vec::new(); write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(mem_buf[]).unwrap(); + let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -3407,7 +3407,7 @@ mod tests { write!(&mut writer, "{}", super::as_pretty_json(&json).indent(i)).unwrap(); - let printed = from_utf8(writer[]).unwrap(); + let printed = from_utf8(writer.index(&FullRange)).unwrap(); // Check for indents at each line let lines: Vec<&str> = printed.lines().collect(); @@ -3477,20 +3477,20 @@ mod tests { r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#, vec![ (ObjectStart, vec![]), - (StringValue("bar".to_string()), vec![Key("foo")]), - (ArrayStart, vec![Key("array")]), - (U64Value(0), vec![Key("array"), Index(0)]), - (U64Value(1), vec![Key("array"), Index(1)]), - (U64Value(2), vec![Key("array"), Index(2)]), - (U64Value(3), vec![Key("array"), Index(3)]), - (U64Value(4), vec![Key("array"), Index(4)]), - (U64Value(5), vec![Key("array"), Index(5)]), - (ArrayEnd, vec![Key("array")]), - (ArrayStart, vec![Key("idents")]), - (NullValue, vec![Key("idents"), Index(0)]), - (BooleanValue(true), vec![Key("idents"), Index(1)]), - (BooleanValue(false), vec![Key("idents"), Index(2)]), - (ArrayEnd, vec![Key("idents")]), + (StringValue("bar".to_string()), vec![StackElement::Key("foo")]), + (ArrayStart, vec![StackElement::Key("array")]), + (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]), + (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]), + (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]), + (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]), + (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]), + (ArrayEnd, vec![StackElement::Key("array")]), + (ArrayStart, vec![StackElement::Key("idents")]), + (NullValue, vec![StackElement::Key("idents"), StackElement::Index(0)]), + (BooleanValue(true), vec![StackElement::Key("idents"), StackElement::Index(1)]), + (BooleanValue(false), vec![StackElement::Key("idents"), StackElement::Index(2)]), + (ArrayEnd, vec![StackElement::Key("idents")]), (ObjectEnd, vec![]), ] ); @@ -3530,7 +3530,7 @@ mod tests { "{\"a\": 3}", vec![ (ObjectStart, vec![]), - (U64Value(3), vec![Key("a")]), + (U64Value(3), vec![StackElement::Key("a")]), (ObjectEnd, vec![]), ] ); @@ -3538,8 +3538,8 @@ mod tests { "{ \"a\": null, \"b\" : true }", vec![ (ObjectStart, vec![]), - (NullValue, vec![Key("a")]), - (BooleanValue(true), vec![Key("b")]), + (NullValue, vec![StackElement::Key("a")]), + (BooleanValue(true), vec![StackElement::Key("b")]), (ObjectEnd, vec![]), ] ); @@ -3547,10 +3547,10 @@ mod tests { "{\"a\" : 1.0 ,\"b\": [ true ]}", vec![ (ObjectStart, vec![]), - (F64Value(1.0), vec![Key("a")]), - (ArrayStart, vec![Key("b")]), - (BooleanValue(true),vec![Key("b"), Index(0)]), - (ArrayEnd, vec![Key("b")]), + (F64Value(1.0), vec![StackElement::Key("a")]), + (ArrayStart, vec![StackElement::Key("b")]), + (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]), + (ArrayEnd, vec![StackElement::Key("b")]), (ObjectEnd, vec![]), ] ); @@ -3565,16 +3565,16 @@ mod tests { }"#, vec![ (ObjectStart, vec![]), - (F64Value(1.0), vec![Key("a")]), - (ArrayStart, vec![Key("b")]), - (BooleanValue(true), vec![Key("b"), Index(0)]), - (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]), - (ObjectStart, vec![Key("b"), Index(2)]), - (ObjectStart, vec![Key("b"), Index(2), Key("c")]), - (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]), - (ObjectEnd, vec![Key("b"), Index(2), Key("c")]), - (ObjectEnd, vec![Key("b"), Index(2)]), - (ArrayEnd, vec![Key("b")]), + (F64Value(1.0), vec![StackElement::Key("a")]), + (ArrayStart, vec![StackElement::Key("b")]), + (BooleanValue(true), vec![StackElement::Key("b"), StackElement::Index(0)]), + (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"), StackElement::Index(1)]), + (ObjectStart, vec![StackElement::Key("b"), StackElement::Index(2)]), + (ObjectStart, vec![StackElement::Key("b"), StackElement::Index(2), StackElement::Key("c")]), + (NullValue, vec![StackElement::Key("b"), StackElement::Index(2), StackElement::Key("c"), StackElement::Key("d")]), + (ObjectEnd, vec![StackElement::Key("b"), StackElement::Index(2), StackElement::Key("c")]), + (ObjectEnd, vec![StackElement::Key("b"), StackElement::Index(2)]), + (ArrayEnd, vec![StackElement::Key("b")]), (ObjectEnd, vec![]), ] ); @@ -3600,7 +3600,7 @@ mod tests { "[true]", vec![ (ArrayStart, vec![]), - (BooleanValue(true), vec![Index(0)]), + (BooleanValue(true), vec![StackElement::Index(0)]), (ArrayEnd, vec![]), ] ); @@ -3608,7 +3608,7 @@ mod tests { "[ false ]", vec![ (ArrayStart, vec![]), - (BooleanValue(false), vec![Index(0)]), + (BooleanValue(false), vec![StackElement::Index(0)]), (ArrayEnd, vec![]), ] ); @@ -3616,7 +3616,7 @@ mod tests { "[null]", vec![ (ArrayStart, vec![]), - (NullValue, vec![Index(0)]), + (NullValue, vec![StackElement::Index(0)]), (ArrayEnd, vec![]), ] ); @@ -3624,8 +3624,8 @@ mod tests { "[3, 1]", vec![ (ArrayStart, vec![]), - (U64Value(3), vec![Index(0)]), - (U64Value(1), vec![Index(1)]), + (U64Value(3), vec![StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Index(1)]), (ArrayEnd, vec![]), ] ); @@ -3633,8 +3633,8 @@ mod tests { "\n[3, 2]\n", vec![ (ArrayStart, vec![]), - (U64Value(3), vec![Index(0)]), - (U64Value(2), vec![Index(1)]), + (U64Value(3), vec![StackElement::Index(0)]), + (U64Value(2), vec![StackElement::Index(1)]), (ArrayEnd, vec![]), ] ); @@ -3642,11 +3642,11 @@ mod tests { "[2, [4, 1]]", vec![ (ArrayStart, vec![]), - (U64Value(2), vec![Index(0)]), - (ArrayStart, vec![Index(1)]), - (U64Value(4), vec![Index(1), Index(0)]), - (U64Value(1), vec![Index(1), Index(1)]), - (ArrayEnd, vec![Index(1)]), + (U64Value(2), vec![StackElement::Index(0)]), + (ArrayStart, vec![StackElement::Index(1)]), + (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]), + (ArrayEnd, vec![StackElement::Index(1)]), (ArrayEnd, vec![]), ] ); @@ -3695,50 +3695,50 @@ mod tests { stack.bump_index(); assert!(stack.len() == 1); - assert!(stack.is_equal_to(&[Index(1)])); - assert!(stack.starts_with(&[Index(1)])); - assert!(stack.ends_with(&[Index(1)])); + assert!(stack.is_equal_to(&[StackElement::Index(1)])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1)])); assert!(stack.last_is_index()); - assert!(stack.get(0) == Index(1)); + assert!(stack.get(0) == StackElement::Index(1)); stack.push_key("foo".to_string()); assert!(stack.len() == 2); - assert!(stack.is_equal_to(&[Index(1), Key("foo")])); - assert!(stack.starts_with(&[Index(1), Key("foo")])); - assert!(stack.starts_with(&[Index(1)])); - assert!(stack.ends_with(&[Index(1), Key("foo")])); - assert!(stack.ends_with(&[Key("foo")])); + assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.ends_with(&[StackElement::Key("foo")])); assert!(!stack.last_is_index()); - assert!(stack.get(0) == Index(1)); - assert!(stack.get(1) == Key("foo")); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); stack.push_key("bar".to_string()); assert!(stack.len() == 3); - assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")])); - assert!(stack.starts_with(&[Index(1)])); - assert!(stack.starts_with(&[Index(1), Key("foo")])); - assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")])); - assert!(stack.ends_with(&[Key("bar")])); - assert!(stack.ends_with(&[Key("foo"), Key("bar")])); - assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")])); + assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo"), StackElement::Key("bar")])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo"), StackElement::Key("bar")])); + assert!(stack.ends_with(&[StackElement::Key("bar")])); + assert!(stack.ends_with(&[StackElement::Key("foo"), StackElement::Key("bar")])); + assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo"), StackElement::Key("bar")])); assert!(!stack.last_is_index()); - assert!(stack.get(0) == Index(1)); - assert!(stack.get(1) == Key("foo")); - assert!(stack.get(2) == Key("bar")); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); + assert!(stack.get(2) == StackElement::Key("bar")); stack.pop(); assert!(stack.len() == 2); - assert!(stack.is_equal_to(&[Index(1), Key("foo")])); - assert!(stack.starts_with(&[Index(1), Key("foo")])); - assert!(stack.starts_with(&[Index(1)])); - assert!(stack.ends_with(&[Index(1), Key("foo")])); - assert!(stack.ends_with(&[Key("foo")])); + assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.starts_with(&[StackElement::Index(1)])); + assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")])); + assert!(stack.ends_with(&[StackElement::Key("foo")])); assert!(!stack.last_is_index()); - assert!(stack.get(0) == Index(1)); - assert!(stack.get(1) == Key("foo")); + assert!(stack.get(0) == StackElement::Index(1)); + assert!(stack.get(1) == StackElement::Key("foo")); } #[test] diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs index a04f67f765108..edaee31462c7f 100644 --- a/src/libserialize/serialize.rs +++ b/src/libserialize/serialize.rs @@ -326,7 +326,7 @@ impl Encodable for str { impl Encodable for String { fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(self[]) + s.emit_str(self.index(&FullRange)) } } diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index e48137047b0a9..50538d3e43def 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -37,7 +37,7 @@ pub fn on_fail(obj: &(Any+Send), file: &'static str, line: uint) { let msg = match obj.downcast_ref::<&'static str>() { Some(s) => *s, None => match obj.downcast_ref::() { - Some(s) => s[], + Some(s) => s.index(&FullRange), None => "Box", } }; diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index d590aa8419453..11d48dff32aed 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -15,7 +15,7 @@ use cmp; use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult}; use iter::{IteratorExt, ExactSizeIterator}; -use ops::Drop; +use ops::{Drop, Index}; use option::Option; use option::Option::{Some, None}; use result::Result::Ok; @@ -100,7 +100,7 @@ impl Buffer for BufferedReader { self.cap = try!(self.inner.read(self.buf.as_mut_slice())); self.pos = 0; } - Ok(self.buf[self.pos..self.cap]) + Ok(self.buf.index(&(self.pos..self.cap))) } fn consume(&mut self, amt: uint) { @@ -117,7 +117,7 @@ impl Reader for BufferedReader { let nread = { let available = try!(self.fill_buf()); let nread = cmp::min(available.len(), buf.len()); - slice::bytes::copy_memory(buf, available[..nread]); + slice::bytes::copy_memory(buf, available.index(&(0..nread))); nread }; self.pos += nread; @@ -171,7 +171,7 @@ impl BufferedWriter { fn flush_buf(&mut self) -> IoResult<()> { if self.pos != 0 { - let ret = self.inner.as_mut().unwrap().write(self.buf[..self.pos]); + let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos))); self.pos = 0; ret } else { @@ -263,9 +263,9 @@ impl Writer for LineBufferedWriter { fn write(&mut self, buf: &[u8]) -> IoResult<()> { match buf.iter().rposition(|&b| b == b'\n') { Some(i) => { - try!(self.inner.write(buf[..i + 1])); + try!(self.inner.write(buf.index(&(0..(i + 1))))); try!(self.inner.flush()); - try!(self.inner.write(buf[i + 1..])); + try!(self.inner.write(buf.index(&((i + 1)..)))); Ok(()) } None => self.inner.write(buf), @@ -517,7 +517,7 @@ mod test { assert_eq!(a, w.get_ref()[]); let w = w.into_inner(); let a: &[_] = &[0, 1]; - assert_eq!(a, w[]); + assert_eq!(a, w.index(&FullRange)); } // This is just here to make sure that we don't infinite loop in the @@ -614,14 +614,14 @@ mod test { #[test] fn read_char_buffered() { let buf = [195u8, 159u8]; - let mut reader = BufferedReader::with_capacity(1, buf[]); + let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange)); assert_eq!(reader.read_char(), Ok('ß')); } #[test] fn test_chars() { let buf = [195u8, 159u8, b'a']; - let mut reader = BufferedReader::with_capacity(1, buf[]); + let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange)); let mut it = reader.chars(); assert_eq!(it.next(), Some(Ok('ß'))); assert_eq!(it.next(), Some(Ok('a'))); diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index f47f6237b7291..bcd0c09b77d61 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -13,6 +13,7 @@ use cmp; use sync::mpsc::{Sender, Receiver}; use io; use option::Option::{None, Some}; +use ops::Index; use result::Result::{Ok, Err}; use slice::{bytes, SliceExt}; use super::{Buffer, Reader, Writer, IoResult}; @@ -90,7 +91,7 @@ impl Reader for ChanReader { Some(src) => { let dst = buf.slice_from_mut(num_read); let count = cmp::min(src.len(), dst.len()); - bytes::copy_memory(dst, src[..count]); + bytes::copy_memory(dst, src.index(&(0..count))); count }, None => 0, diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 4691c06c1de16..0fffb2fafbe6c 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -889,7 +889,7 @@ mod test { let mut read_buf = [0; 1028]; let read_str = match check!(read_stream.read(&mut read_buf)) { -1|0 => panic!("shouldn't happen"), - n => str::from_utf8(read_buf[..n]).unwrap().to_string() + n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string() }; assert_eq!(read_str.as_slice(), message); } diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 5c17644a1ace7..2c2824cbb3bc1 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -13,6 +13,7 @@ //! Readers and Writers for in-memory buffers use cmp::min; +use prelude::Index; use option::Option::None; use result::Result::{Err, Ok}; use io; @@ -159,7 +160,7 @@ impl Reader for MemReader { let write_len = min(buf.len(), self.buf.len() - self.pos); { - let input = self.buf[self.pos.. self.pos + write_len]; + let input = self.buf.index(&(self.pos.. (self.pos + write_len))); let output = buf.slice_to_mut(write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); @@ -187,7 +188,7 @@ impl Buffer for MemReader { #[inline] fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { if self.pos < self.buf.len() { - Ok(self.buf[self.pos..]) + Ok(self.buf.index(&(self.pos..))) } else { Err(io::standard_error(io::EndOfFile)) } @@ -204,7 +205,7 @@ impl<'a> Reader for &'a [u8] { let write_len = min(buf.len(), self.len()); { - let input = self[..write_len]; + let input = self.index(&(0..write_len)); let output = buf.slice_to_mut(write_len); slice::bytes::copy_memory(output, input); } @@ -227,7 +228,7 @@ impl<'a> Buffer for &'a [u8] { #[inline] fn consume(&mut self, amt: uint) { - *self = self[amt..]; + *self = self.index(&(amt..)); } } @@ -286,7 +287,7 @@ impl<'a> Writer for BufWriter<'a> { Ok(()) } else { - slice::bytes::copy_memory(dst, src[..dst_len]); + slice::bytes::copy_memory(dst, src.index(&(0..dst_len))); self.pos += dst_len; @@ -349,7 +350,7 @@ impl<'a> Reader for BufReader<'a> { let write_len = min(buf.len(), self.buf.len() - self.pos); { - let input = self.buf[self.pos.. self.pos + write_len]; + let input = self.buf.index(&(self.pos.. (self.pos + write_len))); let output = buf.slice_to_mut(write_len); assert_eq!(input.len(), output.len()); slice::bytes::copy_memory(output, input); @@ -377,7 +378,7 @@ impl<'a> Buffer for BufReader<'a> { #[inline] fn fill_buf(&mut self) -> IoResult<&[u8]> { if self.pos < self.buf.len() { - Ok(self.buf[self.pos..]) + Ok(self.buf.index(&(self.pos..))) } else { Err(io::standard_error(io::EndOfFile)) } @@ -498,7 +499,7 @@ mod test { assert_eq!(buf, b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf[0..3], b); + assert_eq!(buf.index(&(0..3)), b); assert!(reader.read(&mut buf).is_err()); let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7)); assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); @@ -524,7 +525,7 @@ mod test { assert_eq!(buf.as_slice(), b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf[0..3], b); + assert_eq!(buf.index(&(0..3)), b); assert!(reader.read(&mut buf).is_err()); let mut reader = &mut in_buf.as_slice(); assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); @@ -551,7 +552,7 @@ mod test { assert_eq!(buf, b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; - assert_eq!(buf[0..3], b); + assert_eq!(buf.index(&(0..3)), b); assert!(reader.read(&mut buf).is_err()); let mut reader = BufReader::new(in_buf.as_slice()); assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 5bef473db990c..465c4f9c5c7d2 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -234,7 +234,7 @@ use int; use iter::{Iterator, IteratorExt}; use kinds::Sized; use mem::transmute; -use ops::FnOnce; +use ops::{FnOnce, Index}; use option::Option; use option::Option::{Some, None}; use os; @@ -1068,7 +1068,7 @@ pub trait Writer { fn write_char(&mut self, c: char) -> IoResult<()> { let mut buf = [0u8; 4]; let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0); - self.write(buf[..n]) + self.write(buf.index(&(0..n))) } /// Write the result of passing n through `int::to_str_bytes`. @@ -1453,7 +1453,7 @@ pub trait Buffer: Reader { }; match available.iter().position(|&b| b == byte) { Some(i) => { - res.push_all(available[..i + 1]); + res.push_all(available.index(&(0..(i + 1)))); used = i + 1; break } @@ -1492,7 +1492,7 @@ pub trait Buffer: Reader { } } } - match str::from_utf8(buf[..width]).ok() { + match str::from_utf8(buf.index(&(0..width))).ok() { Some(s) => Ok(s.char_at(0)), None => Err(standard_error(InvalidInput)) } diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index d398b61fe64cf..6cb2463fcbca5 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -22,7 +22,7 @@ use fmt; use io::{self, IoResult, IoError}; use io::net; use iter::{Iterator, IteratorExt}; -use ops::{FnOnce, FnMut}; +use ops::{FnOnce, FnMut, Index}; use option::Option; use option::Option::{None, Some}; use result::Result::{Ok, Err}; @@ -313,7 +313,7 @@ impl<'a> Parser<'a> { let mut tail = [0u16; 8]; let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size); - Some(ipv6_addr_from_head_tail(head[..head_size], tail[..tail_size])) + Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size)))) } fn read_ipv6_addr(&mut self) -> Option { diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index 86fa68d63ac89..c0254a3e7a205 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -59,7 +59,7 @@ impl Reader for LimitReader { impl Buffer for LimitReader { fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> { let amt = try!(self.inner.fill_buf()); - let buf = amt[..cmp::min(amt.len(), self.limit)]; + let buf = amt.index(&(0..cmp::min(amt.len(), self.limit))); if buf.len() == 0 { Err(io::standard_error(io::EndOfFile)) } else { @@ -220,7 +220,7 @@ impl TeeReader { impl Reader for TeeReader { fn read(&mut self, buf: &mut [u8]) -> io::IoResult { self.reader.read(buf).and_then(|len| { - self.writer.write(buf[mut ..len]).map(|()| len) + self.writer.write(buf.index_mut(&(0..len))).map(|()| len) }) } } @@ -234,7 +234,7 @@ pub fn copy(r: &mut R, w: &mut W) -> io::IoResult<()> { Err(ref e) if e.kind == io::EndOfFile => return Ok(()), Err(e) => return Err(e), }; - try!(w.write(buf[..len])); + try!(w.write(buf.index(&(0..len)))); } } diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index b020164158cff..021aae5a6011a 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -68,6 +68,7 @@ use fmt; use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; +use prelude::{FullRange, Index}; use str; use str::StrExt; use string::{String, CowString}; @@ -351,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { match name.rposition_elem(&dot) { None | Some(0) => name, Some(1) if name == b".." => name, - Some(pos) => name[..pos] + Some(pos) => name.index(&(0..pos)) } }) } @@ -398,7 +399,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { match name.rposition_elem(&dot) { None | Some(0) => None, Some(1) if name == b".." => None, - Some(pos) => Some(name[pos+1..]) + Some(pos) => Some(name.index(&((pos+1)..))) } } } @@ -474,7 +475,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { let extlen = extension.container_as_bytes().len(); match (name.rposition_elem(&dot), extlen) { (None, 0) | (Some(0), 0) => None, - (Some(idx), 0) => Some(name[..idx].to_vec()), + (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()), (idx, extlen) => { let idx = match idx { None | Some(0) => name.len(), @@ -483,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { let mut v; v = Vec::with_capacity(idx + extlen + 1); - v.push_all(name[..idx]); + v.push_all(name.index(&(0..idx))); v.push(dot); v.push_all(extension.container_as_bytes()); Some(v) @@ -869,7 +870,7 @@ impl BytesContainer for String { } #[inline] fn container_as_str(&self) -> Option<&str> { - Some(self[]) + Some(self.index(&FullRange)) } #[inline] fn is_str(_: Option<&String>) -> bool { true } @@ -885,7 +886,7 @@ impl BytesContainer for [u8] { impl BytesContainer for Vec { #[inline] fn container_as_bytes(&self) -> &[u8] { - self[] + self.index(&FullRange) } } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index d9981ace0301e..7f37d3b23c8f0 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -16,6 +16,7 @@ use hash; use io::Writer; use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map}; +use prelude::v1::Index; use kinds::Sized; use option::Option::{self, Some, None}; use slice::{AsSlice, Split, SliceExt, SliceConcatExt}; @@ -119,7 +120,7 @@ impl GenericPathUnsafe for Path { None => { self.repr = Path::normalize(filename); } - Some(idx) if self.repr[idx+1..] == b".." => { + Some(idx) if self.repr.index(&((idx+1)..)) == b".." => { let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len()); v.push_all(self.repr.as_slice()); v.push(SEP_BYTE); @@ -129,7 +130,7 @@ impl GenericPathUnsafe for Path { } Some(idx) => { let mut v = Vec::with_capacity(idx + 1 + filename.len()); - v.push_all(self.repr[..idx+1]); + v.push_all(self.repr.index(&(0..(idx+1)))); v.push_all(filename); // FIXME: this is slow self.repr = Path::normalize(v.as_slice()); @@ -170,9 +171,9 @@ impl GenericPath for Path { match self.sepidx { None if b".." == self.repr => self.repr.as_slice(), None => dot_static, - Some(0) => self.repr[..1], - Some(idx) if self.repr[idx+1..] == b".." => self.repr.as_slice(), - Some(idx) => self.repr[..idx] + Some(0) => self.repr.index(&(0..1)), + Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(), + Some(idx) => self.repr.index(&(0..idx)) } } @@ -181,9 +182,9 @@ impl GenericPath for Path { None if b"." == self.repr || b".." == self.repr => None, None => Some(self.repr.as_slice()), - Some(idx) if self.repr[idx+1..] == b".." => None, - Some(0) if self.repr[1..].is_empty() => None, - Some(idx) => Some(self.repr[idx+1..]) + Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None, + Some(0) if self.repr.index(&(1..)).is_empty() => None, + Some(idx) => Some(self.repr.index(&((idx+1)..))) } } @@ -325,7 +326,7 @@ impl Path { // borrowck is being very picky let val = { let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE; - let v_ = if is_abs { v.as_slice()[1..] } else { v.as_slice() }; + let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() }; let comps = normalize_helper(v_, is_abs); match comps { None => None, @@ -364,7 +365,7 @@ impl Path { /// A path of "/" yields no components. A path of "." yields one component. pub fn components<'a>(&'a self) -> Components<'a> { let v = if self.repr[0] == SEP_BYTE { - self.repr[1..] + self.repr.index(&(1..)) } else { self.repr.as_slice() }; let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr let mut ret = v.split(is_sep_byte); diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 4b5d793355b60..d469bb4d767ad 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -24,6 +24,7 @@ use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map, repeat}; use mem; use option::Option::{self, Some, None}; +use prelude::{FullRange, Index}; use slice::{SliceExt, SliceConcatExt}; use str::{SplitTerminator, FromStr, StrExt}; use string::{String, ToString}; @@ -165,30 +166,30 @@ impl GenericPathUnsafe for Path { s.push_str(".."); s.push(SEP); s.push_str(filename); - self.update_normalized(s[]); + self.update_normalized(s.index(&FullRange)); } None => { self.update_normalized(filename); } - Some((_,idxa,end)) if self.repr[idxa..end] == ".." => { + Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => { let mut s = String::with_capacity(end + 1 + filename.len()); - s.push_str(self.repr[0..end]); + s.push_str(self.repr.index(&(0..end))); s.push(SEP); s.push_str(filename); - self.update_normalized(s[]); + self.update_normalized(s.index(&FullRange)); } Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => { let mut s = String::with_capacity(idxb + filename.len()); - s.push_str(self.repr[0..idxb]); + s.push_str(self.repr.index(&(0..idxb))); s.push_str(filename); - self.update_normalized(s[]); + self.update_normalized(s.index(&FullRange)); } Some((idxb,_,_)) => { let mut s = String::with_capacity(idxb + 1 + filename.len()); - s.push_str(self.repr[0..idxb]); + s.push_str(self.repr.index(&(0..idxb))); s.push(SEP); s.push_str(filename); - self.update_normalized(s[]); + self.update_normalized(s.index(&FullRange)); } } } @@ -207,12 +208,12 @@ impl GenericPathUnsafe for Path { let path = path.container_as_str().unwrap(); fn is_vol_abs(path: &str, prefix: Option) -> bool { // assume prefix is Some(DiskPrefix) - let rest = path[prefix_len(prefix)..]; + let rest = path.index(&(prefix_len(prefix)..)); !rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char) } fn shares_volume(me: &Path, path: &str) -> bool { // path is assumed to have a prefix of Some(DiskPrefix) - let repr = me.repr[]; + let repr = me.repr.index(&FullRange); match me.prefix { Some(DiskPrefix) => { repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase() @@ -244,7 +245,7 @@ impl GenericPathUnsafe for Path { else { None }; let pathlen = path_.as_ref().map_or(path.len(), |p| p.len()); let mut s = String::with_capacity(me.repr.len() + 1 + pathlen); - s.push_str(me.repr[]); + s.push_str(me.repr.index(&FullRange)); let plen = me.prefix_len(); // if me is "C:" we don't want to add a path separator match me.prefix { @@ -256,9 +257,9 @@ impl GenericPathUnsafe for Path { } match path_ { None => s.push_str(path), - Some(p) => s.push_str(p[]), + Some(p) => s.push_str(p.index(&FullRange)), }; - me.update_normalized(s[]) + me.update_normalized(s.index(&FullRange)) } if !path.is_empty() { @@ -266,7 +267,7 @@ impl GenericPathUnsafe for Path { match prefix { Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => { // cwd-relative path, self is on the same volume - append_path(self, path[prefix_len(prefix)..]); + append_path(self, path.index(&(prefix_len(prefix)..))); } Some(_) => { // absolute path, or cwd-relative and self is not same volume @@ -312,7 +313,7 @@ impl GenericPath for Path { /// Always returns a `Some` value. #[inline] fn as_str<'a>(&'a self) -> Option<&'a str> { - Some(self.repr[]) + Some(self.repr.index(&FullRange)) } #[inline] @@ -334,17 +335,17 @@ impl GenericPath for Path { /// Always returns a `Some` value. fn dirname_str<'a>(&'a self) -> Option<&'a str> { Some(match self.sepidx_or_prefix_len() { - None if ".." == self.repr => self.repr[], + None if ".." == self.repr => self.repr.index(&FullRange), None => ".", - Some((_,idxa,end)) if self.repr[idxa..end] == ".." => self.repr[], - Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => self.repr[], - Some((0,idxa,_)) => self.repr[0..idxa], + Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => self.repr.index(&FullRange), + Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => self.repr.index(&FullRange), + Some((0,idxa,_)) => self.repr.index(&(0..idxa)), Some((idxb,idxa,_)) => { match self.prefix { Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => { - self.repr[0..idxa] + self.repr.index(&(0..idxa)) } - _ => self.repr[0..idxb] + _ => self.repr.index(&(0..idxb)) } } }) @@ -358,13 +359,13 @@ impl GenericPath for Path { /// See `GenericPath::filename_str` for info. /// Always returns a `Some` value if `filename` returns a `Some` value. fn filename_str<'a>(&'a self) -> Option<&'a str> { - let repr = self.repr[]; + let repr = self.repr.index(&FullRange); match self.sepidx_or_prefix_len() { None if "." == repr || ".." == repr => None, None => Some(repr), - Some((_,idxa,end)) if repr[idxa..end] == ".." => None, + Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None, Some((_,idxa,end)) if idxa == end => None, - Some((_,idxa,end)) => Some(repr[idxa..end]) + Some((_,idxa,end)) => Some(repr.index(&(idxa..end))) } } @@ -396,7 +397,7 @@ impl GenericPath for Path { true } Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false, - Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => false, + Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false, Some((idxb,idxa,_)) => { let trunc = match self.prefix { Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => { @@ -416,15 +417,15 @@ impl GenericPath for Path { if self.prefix.is_some() { Some(Path::new(match self.prefix { Some(DiskPrefix) if self.is_absolute() => { - self.repr[0..self.prefix_len()+1] + self.repr.index(&(0..(self.prefix_len()+1))) } Some(VerbatimDiskPrefix) => { - self.repr[0..self.prefix_len()+1] + self.repr.index(&(0..(self.prefix_len()+1))) } - _ => self.repr[0..self.prefix_len()] + _ => self.repr.index(&(0..self.prefix_len())) })) } else if is_vol_relative(self) { - Some(Path::new(self.repr[0..1])) + Some(Path::new(self.repr.index(&(0..1)))) } else { None } @@ -443,7 +444,7 @@ impl GenericPath for Path { fn is_absolute(&self) -> bool { match self.prefix { Some(DiskPrefix) => { - let rest = self.repr[self.prefix_len()..]; + let rest = self.repr.index(&(self.prefix_len()..)); rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE } Some(_) => true, @@ -618,15 +619,15 @@ impl Path { /// Does not distinguish between absolute and cwd-relative paths, e.g. /// C:\foo and C:foo. pub fn str_components<'a>(&'a self) -> StrComponents<'a> { - let repr = self.repr[]; + let repr = self.repr.index(&FullRange); let s = match self.prefix { Some(_) => { let plen = self.prefix_len(); if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE { - repr[plen+1..] - } else { repr[plen..] } + repr.index(&((plen+1)..)) + } else { repr.index(&(plen..)) } } - None if repr.as_bytes()[0] == SEP_BYTE => repr[1..], + None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)), None => repr }; let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr @@ -646,8 +647,8 @@ impl Path { } fn equiv_prefix(&self, other: &Path) -> bool { - let s_repr = self.repr[]; - let o_repr = other.repr[]; + let s_repr = self.repr.index(&FullRange); + let o_repr = other.repr.index(&FullRange); match (self.prefix, other.prefix) { (Some(DiskPrefix), Some(VerbatimDiskPrefix)) => { self.is_absolute() && @@ -664,14 +665,14 @@ impl Path { o_repr.as_bytes()[4].to_ascii_lowercase() } (Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => { - s_repr[2..self.prefix_len()] == o_repr[8..other.prefix_len()] + s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len())) } (Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => { - s_repr[8..self.prefix_len()] == o_repr[2..other.prefix_len()] + s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len())) } (None, None) => true, (a, b) if a == b => { - s_repr[0..self.prefix_len()] == o_repr[0..other.prefix_len()] + s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len())) } _ => false } @@ -725,7 +726,7 @@ impl Path { match prefix.unwrap() { DiskPrefix => { let len = prefix_len(prefix) + is_abs as uint; - let mut s = String::from_str(s[0..len]); + let mut s = String::from_str(s.index(&(0..len))); unsafe { let v = s.as_mut_vec(); v[0] = (*v)[0].to_ascii_uppercase(); @@ -740,7 +741,7 @@ impl Path { } VerbatimDiskPrefix => { let len = prefix_len(prefix) + is_abs as uint; - let mut s = String::from_str(s[0..len]); + let mut s = String::from_str(s.index(&(0..len))); unsafe { let v = s.as_mut_vec(); v[4] = (*v)[4].to_ascii_uppercase(); @@ -750,14 +751,14 @@ impl Path { _ => { let plen = prefix_len(prefix); if s.len() > plen { - Some(String::from_str(s[0..plen])) + Some(String::from_str(s.index(&(0..plen)))) } else { None } } } } else if is_abs && comps.is_empty() { Some(repeat(SEP).take(1).collect()) } else { - let prefix_ = s[0..prefix_len(prefix)]; + let prefix_ = s.index(&(0..prefix_len(prefix))); let n = prefix_.len() + if is_abs { comps.len() } else { comps.len() - 1} + comps.iter().map(|v| v.len()).sum(); @@ -768,15 +769,15 @@ impl Path { s.push(':'); } Some(VerbatimDiskPrefix) => { - s.push_str(prefix_[0..4]); + s.push_str(prefix_.index(&(0..4))); s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char); - s.push_str(prefix_[5..]); + s.push_str(prefix_.index(&(5..))); } Some(UNCPrefix(a,b)) => { s.push_str("\\\\"); - s.push_str(prefix_[2..a+2]); + s.push_str(prefix_.index(&(2..(a+2)))); s.push(SEP); - s.push_str(prefix_[3+a..3+a+b]); + s.push_str(prefix_.index(&((3+a)..(3+a+b)))); } Some(_) => s.push_str(prefix_), None => () @@ -801,8 +802,8 @@ impl Path { fn update_sepidx(&mut self) { let s = if self.has_nonsemantic_trailing_slash() { - self.repr[0..self.repr.len()-1] - } else { self.repr[] }; + self.repr.index(&(0..(self.repr.len()-1))) + } else { self.repr.index(&FullRange) }; let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) { is_sep } else { @@ -881,17 +882,17 @@ pub fn is_verbatim(path: &Path) -> bool { /// non-verbatim, the non-verbatim version is returned. /// Otherwise, None is returned. pub fn make_non_verbatim(path: &Path) -> Option { - let repr = path.repr[]; + let repr = path.repr.index(&FullRange); let new_path = match path.prefix { Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None, Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()), Some(VerbatimDiskPrefix) => { // \\?\D:\ - Path::new(repr[4..]) + Path::new(repr.index(&(4..))) } Some(VerbatimUNCPrefix(_,_)) => { // \\?\UNC\server\share - Path::new(format!(r"\{}", repr[7..])) + Path::new(format!(r"\{}", repr.index(&(7..)))) } }; if new_path.prefix.is_none() { @@ -900,8 +901,8 @@ pub fn make_non_verbatim(path: &Path) -> Option { return None; } // now ensure normalization didn't change anything - if repr[path.prefix_len()..] == - new_path.repr[new_path.prefix_len()..] { + if repr.index(&(path.prefix_len()..)) == + new_path.repr.index(&(new_path.prefix_len()..)) { Some(new_path) } else { None @@ -966,13 +967,13 @@ pub enum PathPrefix { fn parse_prefix<'a>(mut path: &'a str) -> Option { if path.starts_with("\\\\") { // \\ - path = path[2..]; + path = path.index(&(2..)); if path.starts_with("?\\") { // \\?\ - path = path[2..]; + path = path.index(&(2..)); if path.starts_with("UNC\\") { // \\?\UNC\server\share - path = path[4..]; + path = path.index(&(4..)); let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) { Some(x) => x, None => (path.len(), 0) @@ -993,7 +994,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option { } } else if path.starts_with(".\\") { // \\.\path - path = path[2..]; + path = path.index(&(2..)); let idx = path.find('\\').unwrap_or(path.len()); return Some(DeviceNSPrefix(idx)); } @@ -1018,7 +1019,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option { None => return None, Some(x) => x }; - path = path[idx_a+1..]; + path = path.index(&((idx_a+1)..)); let idx_b = path.find(f).unwrap_or(path.len()); Some((idx_a, idx_b)) } @@ -1032,8 +1033,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option) -> (bool, Option is_sep_verbatim }; let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix))); - let s_ = s[prefix_len(prefix)..]; - let s_ = if is_abs { s_[1..] } else { s_ }; + let s_ = s.index(&(prefix_len(prefix)..)); + let s_ = if is_abs { s_.index(&(1..)) } else { s_ }; if is_abs && s_.is_empty() { return (is_abs, match prefix { diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 71169386c186a..fd84f22094282 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -544,7 +544,7 @@ fn begin_unwind_inner(msg: Box, file_line: &(&'static str, uint)) -> // MAX_CALLBACKS, so we're sure to clamp it as necessary. let callbacks = { let amt = CALLBACK_CNT.load(Ordering::SeqCst); - CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)] + CALLBACKS.index(&(0..cmp::min(amt, MAX_CALLBACKS))) }; for cb in callbacks.iter() { match cb.load(Ordering::SeqCst) { diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index bc01ce926f8bc..59f654a95caa6 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -131,7 +131,7 @@ pub fn abort(args: fmt::Arguments) -> ! { impl<'a> fmt::Writer for BufWriter<'a> { fn write_str(&mut self, bytes: &str) -> fmt::Result { let left = self.buf.slice_from_mut(self.pos); - let to_write = bytes.as_bytes()[..cmp::min(bytes.len(), left.len())]; + let to_write = bytes.as_bytes().index(&(0..cmp::min(bytes.len(), left.len()))); slice::bytes::copy_memory(left, to_write); self.pos += to_write.len(); Ok(()) @@ -142,7 +142,7 @@ pub fn abort(args: fmt::Arguments) -> ! { let mut msg = [0u8; 512]; let mut w = BufWriter { buf: &mut msg, pos: 0 }; let _ = write!(&mut w, "{}", args); - let msg = str::from_utf8(w.buf[mut ..w.pos]).unwrap_or("aborted"); + let msg = str::from_utf8(w.buf.index_mut(&(0..w.pos))).unwrap_or("aborted"); let msg = if msg.is_empty() {"aborted"} else {msg}; // Give some context to the message diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs index 6836888e67e55..b2cc807eb111d 100644 --- a/src/libstd/sync/mpsc/sync.rs +++ b/src/libstd/sync/mpsc/sync.rs @@ -437,7 +437,8 @@ impl Buffer { let start = self.start; self.size -= 1; self.start = (self.start + 1) % self.buf.len(); - self.buf[start].take().unwrap() + let result = &mut self.buf[start]; + result.take().unwrap() } fn size(&self) -> uint { self.size } diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index 4cf891ac4985e..902942d7244f7 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -469,7 +469,7 @@ pub fn write(fd: sock_t, // Also as with read(), we use MSG_DONTWAIT to guard ourselves // against unforeseen circumstances. let _guard = lock(); - let ptr = buf[written..].as_ptr(); + let ptr = buf.index(&(written..)).as_ptr(); let len = buf.len() - written; match retry(|| write(deadline.is_some(), ptr, len)) { -1 if wouldblock() => {} diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index dfdee0e0385c5..fcde5c01080fd 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -36,7 +36,7 @@ const BUF_BYTES : uint = 2048u; pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { match v.iter().position(|c| *c == 0) { // don't include the 0 - Some(i) => v[..i], + Some(i) => v.index(&(0..i)), None => v } } diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index 9996909f2f5bb..016757ef63e7d 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -453,7 +453,7 @@ impl UnixStream { } let ret = unsafe { libc::WriteFile(self.handle(), - buf[offset..].as_ptr() as libc::LPVOID, + buf.index(&(offset..)).as_ptr() as libc::LPVOID, (buf.len() - offset) as libc::DWORD, &mut bytes_written, &mut overlapped) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7aa7c4fcfb301..54e6a338178e4 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -199,7 +199,7 @@ impl Encodable for Ident { #[cfg(stage0)] impl, E> Decodable for Ident { fn decode(d: &mut D) -> Result { - Ok(str_to_ident(try!(d.read_str())[])) + Ok(str_to_ident(try!(d.read_str()).index(&FullRange))) } } diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index cf09e2777f7c6..efd35f73d4534 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -99,7 +99,7 @@ pub fn path_to_string>(path: PI) -> String { if !s.is_empty() { s.push_str("::"); } - s.push_str(e[]); + s.push_str(e.index(&FullRange)); s }).to_string() } @@ -476,20 +476,20 @@ impl<'ast> Map<'ast> { F: FnOnce(Option<&[Attribute]>) -> T, { let attrs = match self.get(id) { - NodeItem(i) => Some(i.attrs[]), - NodeForeignItem(fi) => Some(fi.attrs[]), + NodeItem(i) => Some(i.attrs.index(&FullRange)), + NodeForeignItem(fi) => Some(fi.attrs.index(&FullRange)), NodeTraitItem(ref tm) => match **tm { - RequiredMethod(ref type_m) => Some(type_m.attrs[]), - ProvidedMethod(ref m) => Some(m.attrs[]), - TypeTraitItem(ref typ) => Some(typ.attrs[]), + RequiredMethod(ref type_m) => Some(type_m.attrs.index(&FullRange)), + ProvidedMethod(ref m) => Some(m.attrs.index(&FullRange)), + TypeTraitItem(ref typ) => Some(typ.attrs.index(&FullRange)), }, NodeImplItem(ref ii) => { match **ii { - MethodImplItem(ref m) => Some(m.attrs[]), - TypeImplItem(ref t) => Some(t.attrs[]), + MethodImplItem(ref m) => Some(m.attrs.index(&FullRange)), + TypeImplItem(ref t) => Some(t.attrs.index(&FullRange)), } } - NodeVariant(ref v) => Some(v.node.attrs[]), + NodeVariant(ref v) => Some(v.node.attrs.index(&FullRange)), // unit/tuple structs take the attributes straight from // the struct definition. // FIXME(eddyb) make this work again (requires access to the map). @@ -513,7 +513,7 @@ impl<'ast> Map<'ast> { NodesMatchingSuffix { map: self, item_name: parts.last().unwrap(), - in_which: parts[..parts.len() - 1], + in_which: parts.index(&(0..(parts.len() - 1))), idx: 0, } } @@ -590,7 +590,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> { None => return false, Some((node_id, name)) => (node_id, name), }; - if part[] != mod_name.as_str() { + if part.index(&FullRange) != mod_name.as_str() { return false; } cursor = self.map.get_parent(mod_id); @@ -628,7 +628,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> { // We are looking at some node `n` with a given name and parent // id; do their names match what I am seeking? fn matches_names(&self, parent_of_n: NodeId, name: Name) -> bool { - name.as_str() == self.item_name[] && + name.as_str() == self.item_name.index(&FullRange) && self.suffix_matches(parent_of_n) } } @@ -1040,7 +1040,7 @@ impl<'a> NodePrinter for pprust::State<'a> { fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String { let id_str = format!(" (id={})", id); - let id_str = if include_id { id_str[] } else { "" }; + let id_str = if include_id { id_str.index(&FullRange) } else { "" }; match map.find(id) { Some(NodeItem(item)) => { diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 5e03afec16cf8..aad6f11520659 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -238,11 +238,11 @@ pub fn impl_pretty_name(trait_ref: &Option, ty: &Ty) -> Ident { match *trait_ref { Some(ref trait_ref) => { pretty.push('.'); - pretty.push_str(pprust::path_to_string(&trait_ref.path)[]); + pretty.push_str(pprust::path_to_string(&trait_ref.path).index(&FullRange)); } None => {} } - token::gensym_ident(pretty[]) + token::gensym_ident(pretty.index(&FullRange)) } pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod { @@ -704,7 +704,7 @@ pub fn pat_is_ident(pat: P) -> bool { pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool { (a.span == b.span) && (a.global == b.global) - && (segments_name_eq(a.segments[], b.segments[])) + && (segments_name_eq(a.segments.index(&FullRange), b.segments.index(&FullRange))) } // are two arrays of segments equal when compared unhygienically? @@ -792,13 +792,13 @@ mod test { #[test] fn idents_name_eq_test() { assert!(segments_name_eq( [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::>()[], + .iter().map(ident_to_segment).collect::>().index(&FullRange), [Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}] - .iter().map(ident_to_segment).collect::>()[])); + .iter().map(ident_to_segment).collect::>().index(&FullRange))); assert!(!segments_name_eq( [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::>()[], + .iter().map(ident_to_segment).collect::>().index(&FullRange), [Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}] - .iter().map(ident_to_segment).collect::>()[])); + .iter().map(ident_to_segment).collect::>().index(&FullRange))); } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 43e23f26e930e..97f70d416db6b 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -97,7 +97,7 @@ impl AttrMetaMethods for MetaItem { fn meta_item_list<'a>(&'a self) -> Option<&'a [P]> { match self.node { - MetaList(_, ref l) => Some(l[]), + MetaList(_, ref l) => Some(l.index(&FullRange)), _ => None } } @@ -136,7 +136,7 @@ impl AttributeMethods for Attribute { let meta = mk_name_value_item_str( InternedString::new("doc"), token::intern_and_get_ident(strip_doc_comment_decoration( - comment.get())[])); + comment.get()).index(&FullRange))); if self.node.style == ast::AttrOuter { f(&mk_attr_outer(self.node.id, meta)) } else { @@ -296,9 +296,9 @@ pub fn find_inline_attr(attrs: &[Attribute]) -> InlineAttr { } MetaList(ref n, ref items) if *n == "inline" => { mark_used(attr); - if contains_name(items[], "always") { + if contains_name(items.index(&FullRange), "always") { InlineAlways - } else if contains_name(items[], "never") { + } else if contains_name(items.index(&FullRange), "never") { InlineNever } else { InlineHint @@ -332,7 +332,7 @@ pub fn cfg_matches(diagnostic: &SpanHandler, cfgs: &[P], cfg: &ast::Me !cfg_matches(diagnostic, cfgs, &*mis[0]) } ast::MetaList(ref pred, _) => { - diagnostic.span_err(cfg.span, format!("invalid predicate `{}`", pred)[]); + diagnostic.span_err(cfg.span, format!("invalid predicate `{}`", pred).index(&FullRange)); false }, ast::MetaWord(_) | ast::MetaNameValue(..) => contains(cfgs, cfg), @@ -396,7 +396,7 @@ pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P]) { if !set.insert(name.clone()) { diagnostic.span_fatal(meta.span, - format!("duplicate meta item `{}`", name)[]); + format!("duplicate meta item `{}`", name).index(&FullRange)); } } } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index a49f2614cd787..6d329fe614c99 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -321,9 +321,9 @@ impl FileMap { lines.get(line_number).map(|&line| { let begin: BytePos = line - self.start_pos; let begin = begin.to_uint(); - let slice = self.src[begin..]; + let slice = self.src.index(&(begin..)); match slice.find('\n') { - Some(e) => slice[0..e], + Some(e) => slice.index(&(0..e)), None => slice }.to_string() }) @@ -368,9 +368,9 @@ impl CodeMap { // FIXME #12884: no efficient/safe way to remove from the start of a string // and reuse the allocation. let mut src = if src.starts_with("\u{feff}") { - String::from_str(src[3..]) + String::from_str(src.index(&(3..))) } else { - String::from_str(src[]) + String::from_str(src.index(&FullRange)) }; // Append '\n' in case it's not already there. @@ -457,8 +457,8 @@ impl CodeMap { if begin.fm.start_pos != end.fm.start_pos { None } else { - Some(begin.fm.src[begin.pos.to_uint().. - end.pos.to_uint()].to_string()) + Some(begin.fm.src.index(&(begin.pos.to_uint().. + end.pos.to_uint())).to_string()) } } diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index c19c06c315587..f43a236341eff 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -123,7 +123,7 @@ impl SpanHandler { panic!(ExplicitBug); } pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! { - self.span_bug(sp, format!("unimplemented {}", msg)[]); + self.span_bug(sp, format!("unimplemented {}", msg).index(&FullRange)); } pub fn handler<'a>(&'a self) -> &'a Handler { &self.handler @@ -166,7 +166,7 @@ impl Handler { self.err_count.get()); } } - self.fatal(s[]); + self.fatal(s.index(&FullRange)); } pub fn warn(&self, msg: &str) { self.emit.borrow_mut().emit(None, msg, None, Warning); @@ -182,7 +182,7 @@ impl Handler { panic!(ExplicitBug); } pub fn unimpl(&self, msg: &str) -> ! { - self.bug(format!("unimplemented {}", msg)[]); + self.bug(format!("unimplemented {}", msg).index(&FullRange)); } pub fn emit(&self, cmsp: Option<(&codemap::CodeMap, Span)>, @@ -277,7 +277,7 @@ fn print_maybe_styled(w: &mut EmitterWriter, // to be miscolored. We assume this is rare enough that we don't // have to worry about it. if msg.ends_with("\n") { - try!(t.write_str(msg[0..msg.len()-1])); + try!(t.write_str(msg.index(&(0..(msg.len()-1))))); try!(t.reset()); try!(t.write_str("\n")); } else { @@ -299,16 +299,16 @@ fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level, } try!(print_maybe_styled(dst, - format!("{}: ", lvl.to_string())[], + format!("{}: ", lvl.to_string()).index(&FullRange), term::attr::ForegroundColor(lvl.color()))); try!(print_maybe_styled(dst, - format!("{}", msg)[], + format!("{}", msg).index(&FullRange), term::attr::Bold)); match code { Some(code) => { let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA); - try!(print_maybe_styled(dst, format!(" [{}]", code.clone())[], style)); + try!(print_maybe_styled(dst, format!(" [{}]", code.clone()).index(&FullRange), style)); } None => () } @@ -398,12 +398,12 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan, // the span) let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id}; let ses = cm.span_to_string(span_end); - try!(print_diagnostic(dst, ses[], lvl, msg, code)); + try!(print_diagnostic(dst, ses.index(&FullRange), lvl, msg, code)); if rsp.is_full_span() { try!(custom_highlight_lines(dst, cm, sp, lvl, lines)); } } else { - try!(print_diagnostic(dst, ss[], lvl, msg, code)); + try!(print_diagnostic(dst, ss.index(&FullRange), lvl, msg, code)); if rsp.is_full_span() { try!(highlight_lines(dst, cm, sp, lvl, lines)); } @@ -413,9 +413,9 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan, Some(code) => match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) { Some(_) => { - try!(print_diagnostic(dst, ss[], Help, + try!(print_diagnostic(dst, ss.index(&FullRange), Help, format!("pass `--explain {}` to see a detailed \ - explanation", code)[], None)); + explanation", code).index(&FullRange), None)); } None => () }, @@ -432,9 +432,9 @@ fn highlight_lines(err: &mut EmitterWriter, let fm = &*lines.file; let mut elided = false; - let mut display_lines = lines.lines[]; + let mut display_lines = lines.lines.index(&FullRange); if display_lines.len() > MAX_LINES { - display_lines = display_lines[0u..MAX_LINES]; + display_lines = display_lines.index(&(0u..MAX_LINES)); elided = true; } // Print the offending lines @@ -494,7 +494,7 @@ fn highlight_lines(err: &mut EmitterWriter, } } try!(print_maybe_styled(err, - format!("{}\n", s)[], + format!("{}\n", s).index(&FullRange), term::attr::ForegroundColor(lvl.color()))); } Ok(()) @@ -514,7 +514,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter, -> io::IoResult<()> { let fm = &*lines.file; - let lines = lines.lines[]; + let lines = lines.lines.index(&FullRange); if lines.len() > MAX_LINES { if let Some(line) = fm.get_line(lines[0]) { try!(write!(&mut w.dst, "{}:{} {}\n", fm.name, @@ -545,7 +545,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter, s.push('^'); s.push('\n'); print_maybe_styled(w, - s[], + s.index(&FullRange), term::attr::ForegroundColor(lvl.color())) } @@ -560,12 +560,12 @@ fn print_macro_backtrace(w: &mut EmitterWriter, codemap::MacroAttribute => ("#[", "]"), codemap::MacroBang => ("", "!") }; - try!(print_diagnostic(w, ss[], Note, + try!(print_diagnostic(w, ss.index(&FullRange), Note, format!("in expansion of {}{}{}", pre, ei.callee.name, - post)[], None)); + post).index(&FullRange), None)); let ss = cm.span_to_string(ei.call_site); - try!(print_diagnostic(w, ss[], Note, "expansion site", None)); + try!(print_diagnostic(w, ss.index(&FullRange), Note, "expansion site", None)); Ok(Some(ei.call_site)) } None => Ok(None) @@ -578,6 +578,6 @@ pub fn expect(diag: &SpanHandler, opt: Option, msg: M) -> T where { match opt { Some(t) => t, - None => diag.handler().bug(msg()[]), + None => diag.handler().bug(msg().index(&FullRange)), } } diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index 720a907fe77f0..0f4ebd74b66c7 100644 --- a/src/libsyntax/diagnostics/plugin.rs +++ b/src/libsyntax/diagnostics/plugin.rs @@ -58,7 +58,7 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt, Some(previous_span) => { ecx.span_warn(span, format!( "diagnostic code {} already used", token::get_ident(code).get() - )[]); + ).index(&FullRange)); ecx.span_note(previous_span, "previous invocation"); }, None => () @@ -87,12 +87,12 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt, if diagnostics.insert(code.name, description).is_some() { ecx.span_err(span, format!( "diagnostic code {} already registered", token::get_ident(*code).get() - )[]); + ).index(&FullRange)); } }); let sym = Ident::new(token::gensym(( "__register_diagnostic_".to_string() + token::get_ident(*code).get() - )[])); + ).index(&FullRange))); MacItems::new(vec![quote_item!(ecx, mod $sym {}).unwrap()].into_iter()) } diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index b77b822a6b2a1..04dec0e802841 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -100,7 +100,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some(('=', _)) => None, Some(('+', operand)) => { Some(token::intern_and_get_ident(format!( - "={}", operand)[])) + "={}", operand).index(&FullRange))) } _ => { cx.span_err(span, "output operand constraint lacks '=' or '+'"); diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 91ae7396ea469..52e402689ba77 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -539,7 +539,7 @@ impl<'a> ExtCtxt<'a> { pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); } pub fn mod_path(&self) -> Vec { let mut v = Vec::new(); - v.push(token::str_to_ident(self.ecfg.crate_name[])); + v.push(token::str_to_ident(self.ecfg.crate_name.index(&FullRange))); v.extend(self.mod_path.iter().map(|a| *a)); return v; } @@ -548,7 +548,7 @@ impl<'a> ExtCtxt<'a> { if self.recursion_count > self.ecfg.recursion_limit { self.span_fatal(ei.call_site, format!("recursion limit reached while expanding the macro `{}`", - ei.callee.name)[]); + ei.callee.name).index(&FullRange)); } let mut call_site = ei.call_site; @@ -670,7 +670,7 @@ pub fn check_zero_tts(cx: &ExtCtxt, tts: &[ast::TokenTree], name: &str) { if tts.len() != 0 { - cx.span_err(sp, format!("{} takes no arguments", name)[]); + cx.span_err(sp, format!("{} takes no arguments", name).index(&FullRange)); } } @@ -683,12 +683,12 @@ pub fn get_single_str_from_tts(cx: &mut ExtCtxt, -> Option { let mut p = cx.new_parser_from_tts(tts); if p.token == token::Eof { - cx.span_err(sp, format!("{} takes 1 argument", name)[]); + cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange)); return None } let ret = cx.expander().fold_expr(p.parse_expr()); if p.token != token::Eof { - cx.span_err(sp, format!("{} takes 1 argument", name)[]); + cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange)); } expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| { s.get().to_string() diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index ea345f3a458f4..e3561e8607084 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -709,7 +709,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { let loc = self.codemap().lookup_char_pos(span.lo); let expr_file = self.expr_str(span, token::intern_and_get_ident(loc.file - .name[])); + .name.index(&FullRange))); let expr_line = self.expr_uint(span, loc.line); let expr_file_line_tuple = self.expr_tuple(span, vec!(expr_file, expr_line)); let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple); diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index 03dd08fdf7fe4..1f1781dceb30b 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -40,14 +40,14 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, ast::LitInt(i, ast::UnsignedIntLit(_)) | ast::LitInt(i, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(i, ast::UnsuffixedIntLit(ast::Plus)) => { - accumulator.push_str(format!("{}", i)[]); + accumulator.push_str(format!("{}", i).index(&FullRange)); } ast::LitInt(i, ast::SignedIntLit(_, ast::Minus)) | ast::LitInt(i, ast::UnsuffixedIntLit(ast::Minus)) => { - accumulator.push_str(format!("-{}", i)[]); + accumulator.push_str(format!("-{}", i).index(&FullRange)); } ast::LitBool(b) => { - accumulator.push_str(format!("{}", b)[]); + accumulator.push_str(format!("{}", b).index(&FullRange)); } ast::LitByte(..) | ast::LitBinary(..) => { @@ -62,5 +62,5 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, } base::MacExpr::new(cx.expr_str( sp, - token::intern_and_get_ident(accumulator[]))) + token::intern_and_get_ident(accumulator.index(&FullRange)))) } diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index 2cf60d30a1b25..02f702248cb66 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -40,7 +40,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree] } } } - let res = str_to_ident(res_str[]); + let res = str_to_ident(res_str.index(&FullRange)); let e = P(ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs index cf29bb048d644..2189f7d83d820 100644 --- a/src/libsyntax/ext/deriving/bounds.rs +++ b/src/libsyntax/ext/deriving/bounds.rs @@ -29,12 +29,12 @@ pub fn expand_deriving_bound(cx: &mut ExtCtxt, "Send" | "Sync" => { return cx.span_err(span, format!("{} is an unsafe trait and it \ - should be implemented explicitly", *tname)[]) + should be implemented explicitly", *tname).index(&FullRange)) } ref tname => { cx.span_bug(span, format!("expected built-in trait name but \ - found {}", *tname)[]) + found {}", *tname).index(&FullRange)) } } }, diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs index 3c74a9f4431df..d9d6cebd05c90 100644 --- a/src/libsyntax/ext/deriving/clone.rs +++ b/src/libsyntax/ext/deriving/clone.rs @@ -80,11 +80,11 @@ fn cs_clone( EnumNonMatchingCollapsed (..) => { cx.span_bug(trait_span, format!("non-matching enum variants in \ - `deriving({})`", name)[]) + `deriving({})`", name).index(&FullRange)) } StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, - format!("static method in `deriving({})`", name)[]) + format!("static method in `deriving({})`", name).index(&FullRange)) } } @@ -101,7 +101,7 @@ fn cs_clone( None => { cx.span_bug(trait_span, format!("unnamed field in normal struct in \ - `deriving({})`", name)[]) + `deriving({})`", name).index(&FullRange)) } }; cx.field_imm(field.span, ident, subcall(field)) diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 8094f0d3de8cc..a9289f0175a69 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -198,7 +198,7 @@ fn decode_static_fields(cx: &mut ExtCtxt, let fields = fields.iter().enumerate().map(|(i, &span)| { getarg(cx, span, token::intern_and_get_ident(format!("_field{}", - i)[]), + i).index(&FullRange)), i) }).collect(); diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 0fceb0fbfdac4..7114217d51d0a 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -183,7 +183,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let name = match name { Some(id) => token::get_ident(id), None => { - token::intern_and_get_ident(format!("_field{}", i)[]) + token::intern_and_get_ident(format!("_field{}", i).index(&FullRange)) } }; let enc = cx.expr_method_call(span, self_.clone(), diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 1aa430c4a0829..8ef9a7dc01239 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -510,15 +510,15 @@ impl<'a> TraitDef<'a> { self, struct_def, type_ident, - self_args[], - nonself_args[]) + self_args.index(&FullRange), + nonself_args.index(&FullRange)) } else { method_def.expand_struct_method_body(cx, self, struct_def, type_ident, - self_args[], - nonself_args[]) + self_args.index(&FullRange), + nonself_args.index(&FullRange)) }; method_def.create_method(cx, @@ -550,15 +550,15 @@ impl<'a> TraitDef<'a> { self, enum_def, type_ident, - self_args[], - nonself_args[]) + self_args.index(&FullRange), + nonself_args.index(&FullRange)) } else { method_def.expand_enum_method_body(cx, self, enum_def, type_ident, self_args, - nonself_args[]) + nonself_args.index(&FullRange)) }; method_def.create_method(cx, @@ -645,7 +645,7 @@ impl<'a> MethodDef<'a> { for (i, ty) in self.args.iter().enumerate() { let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics); - let ident = cx.ident_of(format!("__arg_{}", i)[]); + let ident = cx.ident_of(format!("__arg_{}", i).index(&FullRange)); arg_tys.push((ident, ast_ty)); let arg_expr = cx.expr_ident(trait_.span, ident); @@ -752,7 +752,7 @@ impl<'a> MethodDef<'a> { struct_path, struct_def, format!("__self_{}", - i)[], + i).index(&FullRange), ast::MutImmutable); patterns.push(pat); raw_fields.push(ident_expr); @@ -908,22 +908,22 @@ impl<'a> MethodDef<'a> { .collect::>(); let self_arg_idents = self_arg_names.iter() - .map(|name|cx.ident_of(name[])) + .map(|name|cx.ident_of(name.index(&FullRange))) .collect::>(); // The `vi_idents` will be bound, solely in the catch-all, to // a series of let statements mapping each self_arg to a uint // corresponding to its variant index. let vi_idents: Vec = self_arg_names.iter() - .map(|name| { let vi_suffix = format!("{}_vi", name[]); - cx.ident_of(vi_suffix[]) }) + .map(|name| { let vi_suffix = format!("{}_vi", name.index(&FullRange)); + cx.ident_of(vi_suffix.index(&FullRange)) }) .collect::>(); // Builds, via callback to call_substructure_method, the // delegated expression that handles the catch-all case, // using `__variants_tuple` to drive logic if necessary. let catch_all_substructure = EnumNonMatchingCollapsed( - self_arg_idents, variants[], vi_idents[]); + self_arg_idents, variants.index(&FullRange), vi_idents.index(&FullRange)); // These arms are of the form: // (Variant1, Variant1, ...) => Body1 @@ -945,12 +945,12 @@ impl<'a> MethodDef<'a> { let mut subpats = Vec::with_capacity(self_arg_names.len()); let mut self_pats_idents = Vec::with_capacity(self_arg_names.len() - 1); let first_self_pat_idents = { - let (p, idents) = mk_self_pat(cx, self_arg_names[0][]); + let (p, idents) = mk_self_pat(cx, self_arg_names[0].index(&FullRange)); subpats.push(p); idents }; for self_arg_name in self_arg_names.tail().iter() { - let (p, idents) = mk_self_pat(cx, self_arg_name[]); + let (p, idents) = mk_self_pat(cx, self_arg_name.index(&FullRange)); subpats.push(p); self_pats_idents.push(idents); } @@ -1006,7 +1006,7 @@ impl<'a> MethodDef<'a> { &**variant, field_tuples); let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, self_args[], nonself_args, + cx, trait_, type_ident, self_args.index(&FullRange), nonself_args, &substructure); cx.arm(sp, vec![single_pat], arm_expr) @@ -1059,7 +1059,7 @@ impl<'a> MethodDef<'a> { } let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, self_args[], nonself_args, + cx, trait_, type_ident, self_args.index(&FullRange), nonself_args, &catch_all_substructure); // Builds the expression: @@ -1263,7 +1263,7 @@ impl<'a> TraitDef<'a> { cx.span_bug(sp, "a struct with named and unnamed fields in `derive`"); } }; - let ident = cx.ident_of(format!("{}_{}", prefix, i)[]); + let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange)); paths.push(codemap::Spanned{span: sp, node: ident}); let val = cx.expr( sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))))); @@ -1309,7 +1309,7 @@ impl<'a> TraitDef<'a> { let mut ident_expr = Vec::new(); for (i, va) in variant_args.iter().enumerate() { let sp = self.set_expn_info(cx, va.ty.span); - let ident = cx.ident_of(format!("{}_{}", prefix, i)[]); + let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange)); let path1 = codemap::Spanned{span: sp, node: ident}; paths.push(path1); let expr_path = cx.expr_path(cx.path_ident(sp, ident)); @@ -1352,7 +1352,7 @@ pub fn cs_fold(use_foldl: bool, field.span, old, field.self_.clone(), - field.other[]) + field.other.index(&FullRange)) }) } else { all_fields.iter().rev().fold(base, |old, field| { @@ -1360,12 +1360,12 @@ pub fn cs_fold(use_foldl: bool, field.span, old, field.self_.clone(), - field.other[]) + field.other.index(&FullRange)) }) } }, EnumNonMatchingCollapsed(ref all_args, _, tuple) => - enum_nonmatch_f.call_mut((cx, trait_span, (all_args[], tuple), + enum_nonmatch_f.call_mut((cx, trait_span, (all_args.index(&FullRange), tuple), substructure.nonself_args)), StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, "static function in `derive`") @@ -1405,7 +1405,7 @@ pub fn cs_same_method(f: F, f(cx, trait_span, called) }, EnumNonMatchingCollapsed(ref all_self_args, _, tuple) => - enum_nonmatch_f.call_mut((cx, trait_span, (all_self_args[], tuple), + enum_nonmatch_f.call_mut((cx, trait_span, (all_self_args.index(&FullRange), tuple), substructure.nonself_args)), StaticEnum(..) | StaticStruct(..) => { cx.span_bug(trait_span, "static function in `derive`") diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index e72c83b67c89b..b44aa9dbd9fcb 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -123,7 +123,7 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt, cx.span_err(titem.span, format!("unknown `derive` \ trait: `{}`", - *tname)[]); + *tname).index(&FullRange)); } }; } diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs index eceac4e9a8368..70d6da0f88b02 100644 --- a/src/libsyntax/ext/deriving/show.rs +++ b/src/libsyntax/ext/deriving/show.rs @@ -127,7 +127,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, let formatter = substr.nonself_args[0].clone(); let meth = cx.ident_of("write_fmt"); - let s = token::intern_and_get_ident(format_string[]); + let s = token::intern_and_get_ident(format_string.index(&FullRange)); let format_string = cx.expr_str(span, s); // phew, not our responsibility any more! diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 9fedc4a158e15..eb3544e3c5c7f 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -30,7 +30,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT Some(v) => v }; - let e = match os::getenv(var[]) { + let e = match os::getenv(var.index(&FullRange)) { None => { cx.expr_path(cx.path_all(sp, true, @@ -56,7 +56,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT cx.ident_of("Some")), vec!(cx.expr_str(sp, token::intern_and_get_ident( - s[])))) + s.index(&FullRange))))) } }; MacExpr::new(e) @@ -83,7 +83,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) None => { token::intern_and_get_ident(format!("environment variable `{}` \ not defined", - var)[]) + var).index(&FullRange)) } Some(second) => { match expr_to_string(cx, second, "expected string literal") { @@ -106,7 +106,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(sp, msg.get()); cx.expr_uint(sp, 0) } - Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s[])) + Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s.index(&FullRange))) }; MacExpr::new(e) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 212ec3b090325..75aea623de658 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -287,7 +287,7 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, fld.cx.span_err( pth.span, format!("macro undefined: '{}!'", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); // let compilation continue None @@ -303,7 +303,7 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, }, }); let fm = fresh_mark(); - let marked_before = mark_tts(tts[], fm); + let marked_before = mark_tts(tts.index(&FullRange), fm); // The span that we pass to the expanders we want to // be the root of the call stack. That's the most @@ -314,7 +314,7 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, let opt_parsed = { let expanded = expandfun.expand(fld.cx, mac_span, - marked_before[]); + marked_before.index(&FullRange)); parse_thunk(expanded) }; let parsed = match opt_parsed { @@ -323,8 +323,8 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, fld.cx.span_err( pth.span, format!("non-expression macro in expression position: {}", - extnamestr.get()[] - )[]); + extnamestr.get().index(&FullRange) + ).index(&FullRange)); return None; } }; @@ -334,7 +334,7 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, fld.cx.span_err( pth.span, format!("'{}' is not a tt-style macro", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); None } } @@ -439,7 +439,7 @@ pub fn expand_item(it: P, fld: &mut MacroExpander) if valid_ident { fld.cx.mod_push(it.ident); } - let macro_use = contains_macro_use(fld, new_attrs[]); + let macro_use = contains_macro_use(fld, new_attrs.index(&FullRange)); let result = with_exts_frame!(fld.cx.syntax_env, macro_use, noop_fold_item(it, fld)); @@ -566,7 +566,7 @@ pub fn expand_item_mac(it: P, None => { fld.cx.span_err(path_span, format!("macro undefined: '{}!'", - extnamestr)[]); + extnamestr).index(&FullRange)); // let compilation continue return SmallVector::zero(); } @@ -579,7 +579,7 @@ pub fn expand_item_mac(it: P, format!("macro {}! expects no ident argument, \ given '{}'", extnamestr, - token::get_ident(it.ident))[]); + token::get_ident(it.ident)).index(&FullRange)); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -591,14 +591,14 @@ pub fn expand_item_mac(it: P, } }); // mark before expansion: - let marked_before = mark_tts(tts[], fm); - expander.expand(fld.cx, it.span, marked_before[]) + let marked_before = mark_tts(tts.index(&FullRange), fm); + expander.expand(fld.cx, it.span, marked_before.index(&FullRange)) } IdentTT(ref expander, span) => { if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(path_span, format!("macro {}! expects an ident argument", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -610,13 +610,14 @@ pub fn expand_item_mac(it: P, } }); // mark before expansion: - let marked_tts = mark_tts(tts[], fm); + let marked_tts = mark_tts(tts.index(&FullRange), fm); expander.expand(fld.cx, it.span, it.ident, marked_tts) } MacroRulesTT => { if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(path_span, - format!("macro_rules! expects an ident argument")[]); + format!("macro_rules! expects an ident argument") + .index(&FullRange)); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -648,7 +649,7 @@ pub fn expand_item_mac(it: P, _ => { fld.cx.span_err(it.span, format!("{}! is not legal in item position", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); return SmallVector::zero(); } } @@ -667,7 +668,7 @@ pub fn expand_item_mac(it: P, None => { fld.cx.span_err(path_span, format!("non-item macro in item position: {}", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); return SmallVector::zero(); } }; @@ -913,7 +914,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { None => { fld.cx.span_err(pth.span, format!("macro undefined: '{}!'", - extnamestr)[]); + extnamestr).index(&FullRange)); // let compilation continue return DummyResult::raw_pat(span); } @@ -930,11 +931,11 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { }); let fm = fresh_mark(); - let marked_before = mark_tts(tts[], fm); + let marked_before = mark_tts(tts.index(&FullRange), fm); let mac_span = fld.cx.original_span(); let expanded = match expander.expand(fld.cx, mac_span, - marked_before[]).make_pat() { + marked_before.index(&FullRange)).make_pat() { Some(e) => e, None => { fld.cx.span_err( @@ -942,7 +943,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { format!( "non-pattern macro in pattern position: {}", extnamestr.get() - )[] + ).index(&FullRange) ); return DummyResult::raw_pat(span); } @@ -954,7 +955,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { _ => { fld.cx.span_err(span, format!("{}! is not legal in pattern position", - extnamestr.get())[]); + extnamestr.get()).index(&FullRange)); return DummyResult::raw_pat(span); } } @@ -1231,7 +1232,7 @@ impl Folder for Marker { node: match node { MacInvocTT(path, tts, ctxt) => { MacInvocTT(self.fold_path(path), - self.fold_tts(tts[]), + self.fold_tts(tts.index(&FullRange)), mtwt::apply_mark(self.mark, ctxt)) } }, @@ -1712,7 +1713,7 @@ foo_module!(); let string = ident.get(); "xx" == string }).collect(); - let cxbinds: &[&ast::Ident] = cxbinds[]; + let cxbinds: &[&ast::Ident] = cxbinds.index(&FullRange); let cxbind = match cxbinds { [b] => b, _ => panic!("expected just one binding for ext_cx") diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 1f39555f4962c..85a3a5ebcae3a 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -113,7 +113,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) _ => { ecx.span_err(p.span, format!("expected ident for named argument, found `{}`", - p.this_token_to_string())[]); + p.this_token_to_string()).index(&FullRange)); return None; } }; @@ -126,7 +126,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some(prev) => { ecx.span_err(e.span, format!("duplicate argument named `{}`", - name)[]); + name).index(&FullRange)); ecx.parse_sess.span_diagnostic.span_note(prev.span, "previously here"); continue } @@ -217,7 +217,7 @@ impl<'a, 'b> Context<'a, 'b> { let msg = format!("invalid reference to argument `{}` ({})", arg, self.describe_num_args()); - self.ecx.span_err(self.fmtsp, msg[]); + self.ecx.span_err(self.fmtsp, msg.index(&FullRange)); return; } { @@ -237,7 +237,7 @@ impl<'a, 'b> Context<'a, 'b> { Some(e) => e.span, None => { let msg = format!("there is no argument named `{}`", name); - self.ecx.span_err(self.fmtsp, msg[]); + self.ecx.span_err(self.fmtsp, msg.index(&FullRange)); return; } }; @@ -280,19 +280,19 @@ impl<'a, 'b> Context<'a, 'b> { format!("argument redeclared with type `{}` when \ it was previously `{}`", *ty, - *cur)[]); + *cur).index(&FullRange)); } (&Known(ref cur), _) => { self.ecx.span_err(sp, format!("argument used to format with `{}` was \ attempted to not be used for formatting", - *cur)[]); + *cur).index(&FullRange)); } (_, &Known(ref ty)) => { self.ecx.span_err(sp, format!("argument previously used as a format \ argument attempted to be used as `{}`", - *ty)[]); + *ty).index(&FullRange)); } (_, _) => { self.ecx.span_err(sp, "argument declared with multiple formats"); @@ -357,7 +357,7 @@ impl<'a, 'b> Context<'a, 'b> { /// Translate the accumulated string literals to a literal expression fn trans_literal_string(&mut self) -> P { let sp = self.fmtsp; - let s = token::intern_and_get_ident(self.literal[]); + let s = token::intern_and_get_ident(self.literal.index(&FullRange)); self.literal.clear(); self.ecx.expr_str(sp, s) } @@ -509,7 +509,7 @@ impl<'a, 'b> Context<'a, 'b> { None => continue // error already generated }; - let name = self.ecx.ident_of(format!("__arg{}", i)[]); + let name = self.ecx.ident_of(format!("__arg{}", i).index(&FullRange)); pats.push(self.ecx.pat_ident(e.span, name)); locals.push(Context::format_arg(self.ecx, e.span, arg_ty, self.ecx.expr_ident(e.span, name))); @@ -526,7 +526,7 @@ impl<'a, 'b> Context<'a, 'b> { }; let lname = self.ecx.ident_of(format!("__arg{}", - *name)[]); + *name).index(&FullRange)); pats.push(self.ecx.pat_ident(e.span, lname)); names[self.name_positions[*name]] = Some(Context::format_arg(self.ecx, e.span, arg_ty, @@ -606,7 +606,7 @@ impl<'a, 'b> Context<'a, 'b> { -> P { let trait_ = match *ty { Known(ref tyname) => { - match tyname[] { + match tyname.index(&FullRange) { "" => "Show", "?" => "Show", "e" => "LowerExp", @@ -619,7 +619,7 @@ impl<'a, 'b> Context<'a, 'b> { _ => { ecx.span_err(sp, format!("unknown format trait `{}`", - *tyname)[]); + *tyname).index(&FullRange)); "Dummy" } } @@ -710,7 +710,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span, } if !parser.errors.is_empty() { cx.ecx.span_err(cx.fmtsp, format!("invalid format string: {}", - parser.errors.remove(0))[]); + parser.errors.remove(0)).index(&FullRange)); return DummyResult::raw_expr(sp); } if !cx.literal.is_empty() { diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index 4075b208f7873..49d6b255c81c7 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -223,7 +223,7 @@ pub fn marksof(ctxt: SyntaxContext, stopname: Name) -> Vec { } // the internal function for computing marks -// it's not clear to me whether it's better to use a [] mutable +// it's not clear to me whether it's better to use a .index(&FullRange) mutable // vector or a cons-list for this. fn marksof_internal(ctxt: SyntaxContext, stopname: Name, diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index f1b52fa33c386..66c7381e43344 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -473,7 +473,7 @@ pub fn expand_quote_stmt(cx: &mut ExtCtxt, } fn ids_ext(strs: Vec ) -> Vec { - strs.iter().map(|str| str_to_ident((*str)[])).collect() + strs.iter().map(|str| str_to_ident((*str).index(&FullRange))).collect() } fn id_ext(str: &str) -> ast::Ident { @@ -675,7 +675,7 @@ fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec> { for i in range(0, tt.len()) { seq.push(tt.get_tt(i)); } - mk_tts(cx, seq[]) + mk_tts(cx, seq.index(&FullRange)) } ast::TtToken(sp, ref tok) => { let e_sp = cx.expr_ident(sp, id_ext("_sp")); @@ -764,7 +764,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp)); let mut vector = vec!(stmt_let_sp, stmt_let_tt); - vector.extend(mk_tts(cx, tts[]).into_iter()); + vector.extend(mk_tts(cx, tts.index(&FullRange)).into_iter()); let block = cx.expr_block( cx.block_all(sp, Vec::new(), diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index a49df457cb35b..5c966ed98231f 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -57,7 +57,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let topmost = cx.original_span_in_file(); let loc = cx.codemap().lookup_char_pos(topmost.lo); - let filename = token::intern_and_get_ident(loc.file.name[]); + let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange)); base::MacExpr::new(cx.expr_str(topmost, filename)) } @@ -65,7 +65,7 @@ pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { let s = pprust::tts_to_string(tts); base::MacExpr::new(cx.expr_str(sp, - token::intern_and_get_ident(s[]))) + token::intern_and_get_ident(s.index(&FullRange)))) } pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) @@ -78,7 +78,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) .connect("::"); base::MacExpr::new(cx.expr_str( sp, - token::intern_and_get_ident(string[]))) + token::intern_and_get_ident(string.index(&FullRange)))) } /// include! : parse the given file as an expr @@ -137,7 +137,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(sp, format!("couldn't read {}: {}", file.display(), - e)[]); + e).index(&FullRange)); return DummyResult::expr(sp); } Ok(bytes) => bytes, @@ -147,7 +147,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) // Add this input file to the code map to make it available as // dependency information let filename = file.display().to_string(); - let interned = token::intern_and_get_ident(src[]); + let interned = token::intern_and_get_ident(src.index(&FullRange)); cx.codemap().new_filemap(filename, src); base::MacExpr::new(cx.expr_str(sp, interned)) @@ -155,7 +155,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Err(_) => { cx.span_err(sp, format!("{} wasn't a utf-8 file", - file.display())[]); + file.display()).index(&FullRange)); return DummyResult::expr(sp); } } @@ -177,7 +177,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) match File::open(&file).read_to_end() { Err(e) => { cx.span_err(sp, - format!("couldn't read {}: {}", file.display(), e)[]); + format!("couldn't read {}: {}", file.display(), e).index(&FullRange)); return DummyResult::expr(sp); } Ok(bytes) => { diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 1438d15255495..328e302bef30a 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -153,7 +153,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint { seq.num_captures } &TtDelimited(_, ref delim) => { - count_names(delim.tts[]) + count_names(delim.tts.index(&FullRange)) } &TtToken(_, MatchNt(..)) => { 1 @@ -165,7 +165,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint { pub fn initial_matcher_pos(ms: Rc>, sep: Option, lo: BytePos) -> Box { - let match_idx_hi = count_names(ms[]); + let match_idx_hi = count_names(ms.index(&FullRange)); let matches: Vec<_> = range(0, match_idx_hi).map(|_| Vec::new()).collect(); box MatcherPos { stack: vec![], @@ -229,7 +229,7 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) p_s.span_diagnostic .span_fatal(sp, format!("duplicated bind name: {}", - string.get())[]) + string.get()).index(&FullRange)) } } } @@ -254,13 +254,13 @@ pub fn parse_or_else(sess: &ParseSess, rdr: TtReader, ms: Vec ) -> HashMap> { - match parse(sess, cfg, rdr, ms[]) { + match parse(sess, cfg, rdr, ms.index(&FullRange)) { Success(m) => m, Failure(sp, str) => { - sess.span_diagnostic.span_fatal(sp, str[]) + sess.span_diagnostic.span_fatal(sp, str.index(&FullRange)) } Error(sp, str) => { - sess.span_diagnostic.span_fatal(sp, str[]) + sess.span_diagnostic.span_fatal(sp, str.index(&FullRange)) } } } @@ -341,7 +341,7 @@ pub fn parse(sess: &ParseSess, // Only touch the binders we have actually bound for idx in range(ei.match_lo, ei.match_hi) { let sub = (ei.matches[idx]).clone(); - new_pos.matches[idx] + (&mut new_pos.matches[idx]) .push(Rc::new(MatchedSeq(sub, mk_sp(ei.sp_lo, sp.hi)))); } @@ -386,7 +386,7 @@ pub fn parse(sess: &ParseSess, new_ei.idx += 1u; //we specifically matched zero repeats. for idx in range(ei.match_cur, ei.match_cur + seq.num_captures) { - new_ei.matches[idx].push(Rc::new(MatchedSeq(Vec::new(), sp))); + (&mut new_ei.matches[idx]).push(Rc::new(MatchedSeq(Vec::new(), sp))); } cur_eis.push(new_ei); @@ -444,10 +444,10 @@ pub fn parse(sess: &ParseSess, if token_name_eq(&tok, &token::Eof) { if eof_eis.len() == 1u { let mut v = Vec::new(); - for dv in eof_eis[0].matches.iter_mut() { + for dv in (&mut eof_eis[0]).matches.iter_mut() { v.push(dv.pop().unwrap()); } - return Success(nameize(sess, ms, v[])); + return Success(nameize(sess, ms, v.index(&FullRange))); } else if eof_eis.len() > 1u { return Error(sp, "ambiguity: multiple successful parses".to_string()); } else { @@ -486,7 +486,7 @@ pub fn parse(sess: &ParseSess, TtToken(_, MatchNt(_, name, _, _)) => { let name_string = token::get_ident(name); let match_cur = ei.match_cur; - ei.matches[match_cur].push(Rc::new(MatchedNonterminal( + (&mut ei.matches[match_cur]).push(Rc::new(MatchedNonterminal( parse_nt(&mut rust_parser, name_string.get())))); ei.idx += 1u; ei.match_cur += 1; @@ -522,7 +522,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { _ => { let token_str = pprust::token_to_string(&p.token); p.fatal((format!("expected ident, found {}", - token_str[]))[]) + token_str.index(&FullRange))).index(&FullRange)) } }, "path" => { @@ -536,7 +536,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { res } _ => { - p.fatal(format!("unsupported builtin nonterminal parser: {}", name)[]) + p.fatal(format!("unsupported builtin nonterminal parser: {}", name).index(&FullRange)) } } } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 9837c8088fa45..805af484e281a 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -52,7 +52,7 @@ impl<'a> ParserAnyMacro<'a> { following", token_str); let span = parser.span; - parser.span_err(span, msg[]); + parser.span_err(span, msg.index(&FullRange)); } } } @@ -126,8 +126,8 @@ impl TTMacroExpander for MacroRulesMacroExpander { self.name, self.imported_from, arg, - self.lhses[], - self.rhses[]) + self.lhses.index(&FullRange), + self.rhses.index(&FullRange)) } } @@ -154,7 +154,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, match **lhs { MatchedNonterminal(NtTT(ref lhs_tt)) => { let lhs_tt = match **lhs_tt { - TtDelimited(_, ref delim) => delim.tts[], + TtDelimited(_, ref delim) => delim.tts.index(&FullRange), _ => cx.span_fatal(sp, "malformed macro lhs") }; // `None` is because we're not interpolating @@ -194,13 +194,13 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, best_fail_spot = sp; best_fail_msg = (*msg).clone(); }, - Error(sp, ref msg) => cx.span_fatal(sp, msg[]) + Error(sp, ref msg) => cx.span_fatal(sp, msg.index(&FullRange)) } } _ => cx.bug("non-matcher found in parsed lhses") } } - cx.span_fatal(best_fail_spot, best_fail_msg[]); + cx.span_fatal(best_fail_spot, best_fail_msg.index(&FullRange)); } // Note that macro-by-example's input is also matched against a token tree: diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index e4e6f5ac6b0f0..7ca920a61962a 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -240,7 +240,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { } LisContradiction(ref msg) => { // FIXME #2887 blame macro invoker instead - r.sp_diag.span_fatal(sp.clone(), msg[]); + r.sp_diag.span_fatal(sp.clone(), msg.index(&FullRange)); } LisConstraint(len, _) => { if len == 0 { @@ -297,7 +297,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { r.sp_diag.span_fatal( r.cur_span, /* blame the macro writer */ format!("variable '{}' is still repeating at this depth", - token::get_ident(ident))[]); + token::get_ident(ident)).index(&FullRange)); } } } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 0810d4ee93ac7..afe149e9d6933 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -149,7 +149,7 @@ impl<'a> Context<'a> { self.span_handler.span_err(span, explain); self.span_handler.span_help(span, format!("add #![feature({})] to the \ crate attributes to enable", - feature)[]); + feature).index(&FullRange)); } } @@ -240,7 +240,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } match i.node { ast::ItemForeignMod(ref foreign_module) => { - if attr::contains_name(i.attrs[], "link_args") { + if attr::contains_name(i.attrs.index(&FullRange), "link_args") { self.gate_feature("link_args", i.span, "the `link_args` attribute is not portable \ across platforms, it is recommended to \ @@ -254,14 +254,14 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } ast::ItemFn(..) => { - if attr::contains_name(i.attrs[], "plugin_registrar") { + if attr::contains_name(i.attrs.index(&FullRange), "plugin_registrar") { self.gate_feature("plugin_registrar", i.span, "compiler plugins are experimental and possibly buggy"); } } ast::ItemStruct(..) => { - if attr::contains_name(i.attrs[], "simd") { + if attr::contains_name(i.attrs.index(&FullRange), "simd") { self.gate_feature("simd", i.span, "SIMD types are experimental and possibly buggy"); } @@ -303,7 +303,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } fn visit_foreign_item(&mut self, i: &ast::ForeignItem) { - if attr::contains_name(i.attrs[], "linkage") { + if attr::contains_name(i.attrs.index(&FullRange), "linkage") { self.gate_feature("linkage", i.span, "the `linkage` attribute is experimental \ and not portable across platforms") diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 41693d9d47a51..f4810cee5f89d 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -92,7 +92,7 @@ impl<'a> ParserAttr for Parser<'a> { } _ => { let token_str = self.this_token_to_string(); - self.fatal(format!("expected `#`, found `{}`", token_str)[]); + self.fatal(format!("expected `#`, found `{}`", token_str).index(&FullRange)); } }; diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 0d5592b57b1d1..e7fc5aac9c772 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -82,7 +82,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { while j > i && lines[j - 1].trim().is_empty() { j -= 1; } - return lines[i..j].iter().map(|x| (*x).clone()).collect(); + return lines.index(&(i..j)).iter().map(|x| (*x).clone()).collect(); } /// remove a "[ \t]*\*" block from each line, if possible @@ -116,7 +116,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { if can_trim { lines.iter().map(|line| { - line[i + 1..line.len()].to_string() + line.index(&((i + 1)..line.len())).to_string() }).collect() } else { lines @@ -127,12 +127,12 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { static ONLINERS: &'static [&'static str] = &["///!", "///", "//!", "//"]; for prefix in ONLINERS.iter() { if comment.starts_with(*prefix) { - return comment[prefix.len()..].to_string(); + return comment.index(&(prefix.len()..)).to_string(); } } if comment.starts_with("/*") { - let lines = comment[3u..comment.len() - 2u] + let lines = comment.index(&(3u..(comment.len() - 2u))) .lines_any() .map(|s| s.to_string()) .collect:: >(); @@ -187,7 +187,7 @@ fn read_line_comments(rdr: &mut StringReader, code_to_the_left: bool, let line = rdr.read_one_line_comment(); debug!("{}", line); // Doc comments are not put in comments. - if is_doc_comment(line[]) { + if is_doc_comment(line.index(&FullRange)) { break; } lines.push(line); @@ -224,10 +224,10 @@ fn all_whitespace(s: &str, col: CharPos) -> Option { fn trim_whitespace_prefix_and_push_line(lines: &mut Vec , s: String, col: CharPos) { let len = s.len(); - let s1 = match all_whitespace(s[], col) { + let s1 = match all_whitespace(s.index(&FullRange), col) { Some(col) => { if col < len { - s[col..len].to_string() + s.index(&(col..len)).to_string() } else { "".to_string() } @@ -261,7 +261,7 @@ fn read_block_comment(rdr: &mut StringReader, rdr.bump(); rdr.bump(); } - if is_block_doc_comment(curr_line[]) { + if is_block_doc_comment(curr_line.index(&FullRange)) { return } assert!(!curr_line.contains_char('\n')); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index a50b97142c2ef..850d527fe3970 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -196,7 +196,7 @@ impl<'a> StringReader<'a> { let mut m = m.to_string(); m.push_str(": "); for c in c.escape_default() { m.push(c) } - self.fatal_span_(from_pos, to_pos, m[]); + self.fatal_span_(from_pos, to_pos, m.index(&FullRange)); } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an @@ -205,7 +205,7 @@ impl<'a> StringReader<'a> { let mut m = m.to_string(); m.push_str(": "); for c in c.escape_default() { m.push(c) } - self.err_span_(from_pos, to_pos, m[]); + self.err_span_(from_pos, to_pos, m.index(&FullRange)); } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending the @@ -214,8 +214,8 @@ impl<'a> StringReader<'a> { m.push_str(": "); let from = self.byte_offset(from_pos).to_uint(); let to = self.byte_offset(to_pos).to_uint(); - m.push_str(self.filemap.src[from..to]); - self.fatal_span_(from_pos, to_pos, m[]); + m.push_str(self.filemap.src.index(&(from..to))); + self.fatal_span_(from_pos, to_pos, m.index(&FullRange)); } /// Advance peek_tok and peek_span to refer to the next token, and @@ -301,7 +301,7 @@ impl<'a> StringReader<'a> { while i < s.len() { let str::CharRange { ch, next } = s.char_range_at(i); if ch == '\r' { - if j < i { buf.push_str(s[j..i]); } + if j < i { buf.push_str(s.index(&(j..i))); } j = next; if next >= s.len() || s.char_at(next) != '\n' { let pos = start + BytePos(i as u32); @@ -311,7 +311,7 @@ impl<'a> StringReader<'a> { } i = next; } - if j < s.len() { buf.push_str(s[j..]); } + if j < s.len() { buf.push_str(s.index(&(j..))); } buf } } @@ -556,7 +556,7 @@ impl<'a> StringReader<'a> { self.translate_crlf(start_bpos, string, "bare CR not allowed in block doc-comment") } else { string.into_cow() }; - token::DocComment(token::intern(string[])) + token::DocComment(token::intern(string.index(&FullRange))) } else { token::Comment }; @@ -1110,7 +1110,7 @@ impl<'a> StringReader<'a> { // expansion purposes. See #12512 for the gory details of why // this is necessary. let ident = self.with_str_from(start, |lifetime_name| { - str_to_ident(format!("'{}", lifetime_name)[]) + str_to_ident(format!("'{}", lifetime_name).index(&FullRange)) }); // Conjure up a "keyword checking ident" to make sure that diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index b0969a573e66b..24a909cc5fb94 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -256,17 +256,17 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option) Err(e) => { err(format!("couldn't read {}: {}", path.display(), - e)[]); + e).index(&FullRange)); unreachable!() } }; - match str::from_utf8(bytes[]).ok() { + match str::from_utf8(bytes.index(&FullRange)).ok() { Some(s) => { return string_to_filemap(sess, s.to_string(), path.as_str().unwrap().to_string()) } None => { - err(format!("{} is not UTF-8 encoded", path.display())[]) + err(format!("{} is not UTF-8 encoded", path.display()).index(&FullRange)) } } unreachable!() @@ -398,10 +398,10 @@ pub fn char_lit(lit: &str) -> (char, int) { } let msg = format!("lexer should have rejected a bad character escape {}", lit); - let msg2 = msg[]; + let msg2 = msg.index(&FullRange); fn esc(len: uint, lit: &str) -> Option<(char, int)> { - num::from_str_radix(lit[2..len], 16) + num::from_str_radix(lit.index(&(2..len)), 16) .and_then(char::from_u32) .map(|x| (x, len as int)) } @@ -409,7 +409,7 @@ pub fn char_lit(lit: &str) -> (char, int) { let unicode_escape = |&: | -> Option<(char, int)> if lit.as_bytes()[2] == b'{' { let idx = lit.find('}').expect(msg2); - let subslice = lit[3..idx]; + let subslice = lit.index(&(3..idx)); num::from_str_radix(subslice, 16) .and_then(char::from_u32) .map(|x| (x, subslice.chars().count() as int + 4)) @@ -471,7 +471,7 @@ pub fn str_lit(lit: &str) -> String { eat(&mut chars); } else { // otherwise, a normal escape - let (c, n) = char_lit(lit[i..]); + let (c, n) = char_lit(lit.index(&(i..))); for _ in range(0, n - 1) { // we don't need to move past the first \ chars.next(); } @@ -534,7 +534,7 @@ pub fn raw_str_lit(lit: &str) -> String { fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool { s.len() > 1 && first_chars.contains(&s.char_at(0)) && - s[1..].chars().all(|c| '0' <= c && c <= '9') + s.index(&(1..)).chars().all(|c| '0' <= c && c <= '9') } fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, @@ -547,7 +547,7 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) { // if it looks like a width, lets try to be helpful. sd.span_err(sp, &*format!("illegal width `{}` for float literal, \ - valid widths are 32 and 64", suf[1..])); + valid widths are 32 and 64", suf.index(&(1..)))); } else { sd.span_err(sp, &*format!("illegal suffix `{}` for float literal, \ valid suffixes are `f32` and `f64`", suf)); @@ -583,7 +583,7 @@ pub fn byte_lit(lit: &str) -> (u8, uint) { b'\'' => b'\'', b'0' => b'\0', _ => { - match ::std::num::from_str_radix::(lit[2..4], 16) { + match ::std::num::from_str_radix::(lit.index(&(2..4)), 16) { Some(c) => if c > 0xFF { panic!(err(2)) @@ -633,7 +633,7 @@ pub fn binary_lit(lit: &str) -> Rc> { } _ => { // otherwise, a normal escape - let (c, n) = byte_lit(lit[i..]); + let (c, n) = byte_lit(lit.index(&(i..))); // we don't need to move past the first \ for _ in range(0, n - 1) { chars.next(); @@ -662,7 +662,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> // s can only be ascii, byte indexing is fine let s2 = s.chars().filter(|&c| c != '_').collect::(); - let mut s = s2[]; + let mut s = s2.index(&FullRange); debug!("integer_lit: {}, {}", s, suffix); @@ -695,7 +695,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> } if base != 10 { - s = s[2..]; + s = s.index(&(2..)); } if let Some(suf) = suffix { @@ -717,7 +717,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> if looks_like_width_suffix(&['i', 'u'], suf) { sd.span_err(sp, &*format!("illegal width `{}` for integer literal; \ valid widths are 8, 16, 32 and 64", - suf[1..])); + suf.index(&(1..)))); } else { sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf)); } @@ -815,7 +815,7 @@ mod test { #[test] fn string_to_tts_macro () { let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string()); - let tts: &[ast::TokenTree] = tts[]; + let tts: &[ast::TokenTree] = tts.index(&FullRange); match tts { [ast::TtToken(_, token::Ident(name_macro_rules, token::Plain)), ast::TtToken(_, token::Not), @@ -823,19 +823,19 @@ mod test { ast::TtDelimited(_, ref macro_delimed)] if name_macro_rules.as_str() == "macro_rules" && name_zip.as_str() == "zip" => { - match macro_delimed.tts[] { + match macro_delimed.tts.index(&FullRange) { [ast::TtDelimited(_, ref first_delimed), ast::TtToken(_, token::FatArrow), ast::TtDelimited(_, ref second_delimed)] if macro_delimed.delim == token::Paren => { - match first_delimed.tts[] { + match first_delimed.tts.index(&FullRange) { [ast::TtToken(_, token::Dollar), ast::TtToken(_, token::Ident(name, token::Plain))] if first_delimed.delim == token::Paren && name.as_str() == "a" => {}, _ => panic!("value 3: {}", **first_delimed), } - match second_delimed.tts[] { + match second_delimed.tts.index(&FullRange) { [ast::TtToken(_, token::Dollar), ast::TtToken(_, token::Ident(name, token::Plain))] if second_delimed.delim == token::Paren @@ -1113,24 +1113,24 @@ mod test { let use_s = "use foo::bar::baz;"; let vitem = string_to_view_item(use_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s[], use_s); + assert_eq!(vitem_s.index(&FullRange), use_s); let use_s = "use foo::bar as baz;"; let vitem = string_to_view_item(use_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s[], use_s); + assert_eq!(vitem_s.index(&FullRange), use_s); } #[test] fn parse_extern_crate() { let ex_s = "extern crate foo;"; let vitem = string_to_view_item(ex_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s[], ex_s); + assert_eq!(vitem_s.index(&FullRange), ex_s); let ex_s = "extern crate \"foo\" as bar;"; let vitem = string_to_view_item(ex_s.to_string()); let vitem_s = view_item_to_string(&vitem); - assert_eq!(vitem_s[], ex_s); + assert_eq!(vitem_s.index(&FullRange), ex_s); } fn get_spans_of_pat_idents(src: &str) -> Vec { @@ -1209,7 +1209,7 @@ mod test { let docs = item.attrs.iter().filter(|a| a.name().get() == "doc") .map(|a| a.value_str().unwrap().get().to_string()).collect::>(); let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()]; - assert_eq!(docs[], b); + assert_eq!(docs.index(&FullRange), b); let source = "/** doc comment\r\n * with CRLF */\r\nfn foo() {}".to_string(); let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap(); diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index a49680d7e1c03..23728c74ae8b5 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -127,13 +127,13 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> { kind_str: &str, desc: &str) { self.span_err(sp, - format!("obsolete syntax: {}", kind_str)[]); + format!("obsolete syntax: {}", kind_str).index(&FullRange)); if !self.obsolete_set.contains(&kind) { self.sess .span_diagnostic .handler() - .note(format!("{}", desc)[]); + .note(format!("{}", desc).index(&FullRange)); self.obsolete_set.insert(kind); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 32f8f5ee3d63b..f35f42d5aca30 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -389,12 +389,12 @@ impl<'a> Parser<'a> { let token_str = Parser::token_to_string(t); let last_span = self.last_span; self.span_fatal(last_span, format!("unexpected token: `{}`", - token_str)[]); + token_str).index(&FullRange)); } pub fn unexpected(&mut self) -> ! { let this_token = self.this_token_to_string(); - self.fatal(format!("unexpected token: `{}`", this_token)[]); + self.fatal(format!("unexpected token: `{}`", this_token).index(&FullRange)); } /// Expect and consume the token t. Signal an error if @@ -408,7 +408,7 @@ impl<'a> Parser<'a> { let this_token_str = self.this_token_to_string(); self.fatal(format!("expected `{}`, found `{}`", token_str, - this_token_str)[]) + this_token_str).index(&FullRange)) } } else { self.expect_one_of(slice::ref_slice(t), &[]); @@ -449,7 +449,7 @@ impl<'a> Parser<'a> { expected.push_all(&*self.expected_tokens); expected.sort_by(|a, b| a.to_string().cmp(&b.to_string())); expected.dedup(); - let expect = tokens_to_string(expected[]); + let expect = tokens_to_string(expected.index(&FullRange)); let actual = self.this_token_to_string(); self.fatal( (if expected.len() != 1 { @@ -460,7 +460,7 @@ impl<'a> Parser<'a> { (format!("expected {}, found `{}`", expect, actual)) - })[] + }).index(&FullRange) ) } } @@ -493,7 +493,7 @@ impl<'a> Parser<'a> { // might be unit-struct construction; check for recoverableinput error. let mut expected = edible.iter().map(|x| x.clone()).collect::>(); expected.push_all(inedible); - self.check_for_erroneous_unit_struct_expecting(expected[]); + self.check_for_erroneous_unit_struct_expecting(expected.index(&FullRange)); } self.expect_one_of(edible, inedible) } @@ -510,9 +510,9 @@ impl<'a> Parser<'a> { .as_ref() .map_or(false, |t| t.is_ident() || t.is_path()) { let mut expected = edible.iter().map(|x| x.clone()).collect::>(); - expected.push_all(inedible[]); + expected.push_all(inedible.index(&FullRange)); self.check_for_erroneous_unit_struct_expecting( - expected[]); + expected.index(&FullRange)); } self.expect_one_of(edible, inedible) } @@ -535,7 +535,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_string(); self.fatal((format!("expected ident, found `{}`", - token_str))[]) + token_str)).index(&FullRange)) } } } @@ -593,7 +593,7 @@ impl<'a> Parser<'a> { let id_interned_str = token::get_name(kw.to_name()); let token_str = self.this_token_to_string(); self.fatal(format!("expected `{}`, found `{}`", - id_interned_str, token_str)[]) + id_interned_str, token_str).index(&FullRange)) } } @@ -604,7 +604,7 @@ impl<'a> Parser<'a> { let span = self.span; self.span_err(span, format!("expected identifier, found keyword `{}`", - token_str)[]); + token_str).index(&FullRange)); } } @@ -613,7 +613,7 @@ impl<'a> Parser<'a> { if self.token.is_reserved_keyword() { let token_str = self.this_token_to_string(); self.fatal(format!("`{}` is a reserved keyword", - token_str)[]) + token_str).index(&FullRange)) } } @@ -633,7 +633,7 @@ impl<'a> Parser<'a> { Parser::token_to_string(&token::BinOp(token::And)); self.fatal(format!("expected `{}`, found `{}`", found_token, - token_str)[]) + token_str).index(&FullRange)) } } } @@ -654,7 +654,7 @@ impl<'a> Parser<'a> { Parser::token_to_string(&token::BinOp(token::Or)); self.fatal(format!("expected `{}`, found `{}`", token_str, - found_token)[]) + found_token).index(&FullRange)) } } } @@ -697,7 +697,7 @@ impl<'a> Parser<'a> { let token_str = Parser::token_to_string(&token::Lt); self.fatal(format!("expected `{}`, found `{}`", token_str, - found_token)[]) + found_token).index(&FullRange)) } } @@ -749,7 +749,7 @@ impl<'a> Parser<'a> { let this_token_str = self.this_token_to_string(); self.fatal(format!("expected `{}`, found `{}`", gt_str, - this_token_str)[]) + this_token_str).index(&FullRange)) } } } @@ -1369,7 +1369,7 @@ impl<'a> Parser<'a> { let (inner_attrs, body) = p.parse_inner_attrs_and_block(); let mut attrs = attrs; - attrs.push_all(inner_attrs[]); + attrs.push_all(inner_attrs.index(&FullRange)); ProvidedMethod(P(ast::Method { attrs: attrs, id: ast::DUMMY_NODE_ID, @@ -1388,7 +1388,7 @@ impl<'a> Parser<'a> { _ => { let token_str = p.this_token_to_string(); p.fatal((format!("expected `;` or `{{`, found `{}`", - token_str))[]) + token_str)).index(&FullRange)) } } } @@ -1584,7 +1584,7 @@ impl<'a> Parser<'a> { } else { let this_token_str = self.this_token_to_string(); let msg = format!("expected type, found `{}`", this_token_str); - self.fatal(msg[]); + self.fatal(msg.index(&FullRange)); }; let sp = mk_sp(lo, self.last_span.hi); @@ -1726,14 +1726,14 @@ impl<'a> Parser<'a> { token::Str_(s) => { (true, - LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str())[]), + LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str()).index(&FullRange)), ast::CookedStr)) } token::StrRaw(s, n) => { (true, LitStr( token::intern_and_get_ident( - parse::raw_str_lit(s.as_str())[]), + parse::raw_str_lit(s.as_str()).index(&FullRange)), ast::RawStr(n))) } token::Binary(i) => @@ -1977,7 +1977,7 @@ impl<'a> Parser<'a> { }; } _ => { - self.fatal(format!("expected a lifetime name")[]); + self.fatal(format!("expected a lifetime name").index(&FullRange)); } } } @@ -2015,7 +2015,7 @@ impl<'a> Parser<'a> { let msg = format!("expected `,` or `>` after lifetime \ name, found `{}`", this_token_str); - self.fatal(msg[]); + self.fatal(msg.index(&FullRange)); } } } @@ -2515,7 +2515,7 @@ impl<'a> Parser<'a> { let last_span = self.last_span; let fstr = n.as_str(); self.span_err(last_span, - format!("unexpected token: `{}`", n.as_str())[]); + format!("unexpected token: `{}`", n.as_str()).index(&FullRange)); if fstr.chars().all(|x| "0123456789.".contains_char(x)) { let float = match fstr.parse::() { Some(f) => f, @@ -2524,7 +2524,7 @@ impl<'a> Parser<'a> { self.span_help(last_span, format!("try parenthesizing the first index; e.g., `(foo.{}){}`", float.trunc() as uint, - float.fract().to_string()[1..])[]); + float.fract().to_string().index(&(1..))).index(&FullRange)); } self.abort_if_errors(); @@ -2561,18 +2561,18 @@ impl<'a> Parser<'a> { MutImmutable }; match self.token { - // e[] + // e.index(&FullRange) token::CloseDelim(token::Bracket) => { self.bump(); hi = self.span.hi; let slice = self.mk_slice(e, None, None, mutbl); e = self.mk_expr(lo, hi, slice) } - // e[..e] + // e.index(&(0..e)) token::DotDot => { self.bump(); match self.token { - // e[..] + // e.index(&(..)) token::CloseDelim(token::Bracket) => { self.bump(); hi = self.span.hi; @@ -2581,9 +2581,9 @@ impl<'a> Parser<'a> { self.span_err(e.span, "incorrect slicing expression: `[..]`"); self.span_note(e.span, - "use `expr[]` to construct a slice of the whole of expr"); + "use `expr.index(&FullRange)` to construct a slice of the whole of expr"); } - // e[..e] + // e.index(&(0..e)) _ => { hi = self.span.hi; let e2 = self.parse_expr(); @@ -2593,20 +2593,20 @@ impl<'a> Parser<'a> { } } } - // e[e] | e[e..] | e[e..e] + // e[e] | e.index(&(e..)) | e.index(&(e..e)) _ => { let ix = self.parse_expr_res(RESTRICTION_NO_DOTS); match self.token { - // e[e..] | e[e..e] + // e.index(&(e..)) | e.index(&(e..e)) token::DotDot => { self.bump(); let e2 = match self.token { - // e[e..] + // e.index(&(e..)) token::CloseDelim(token::Bracket) => { self.bump(); None } - // e[e..e] + // e.index(&(e..e)) _ => { let e2 = self.parse_expr_res(RESTRICTION_NO_DOTS); self.commit_expr_expecting(&*e2, @@ -2711,7 +2711,7 @@ impl<'a> Parser<'a> { }; let token_str = p.this_token_to_string(); p.fatal(format!("incorrect close delimiter: `{}`", - token_str)[]) + token_str).index(&FullRange)) }, /* we ought to allow different depths of unquotation */ token::Dollar if p.quote_depth > 0u => { @@ -2729,7 +2729,7 @@ impl<'a> Parser<'a> { let seq = match seq { Spanned { node, .. } => node, }; - let name_num = macro_parser::count_names(seq[]); + let name_num = macro_parser::count_names(seq.index(&FullRange)); TtSequence(mk_sp(sp.lo, p.span.hi), Rc::new(SequenceRepetition { tts: seq, @@ -2890,7 +2890,7 @@ impl<'a> Parser<'a> { let this_token_to_string = self.this_token_to_string(); self.span_err(span, format!("expected expression, found `{}`", - this_token_to_string)[]); + this_token_to_string).index(&FullRange)); let box_span = mk_sp(lo, self.last_span.hi); self.span_help(box_span, "perhaps you meant `box() (foo)` instead?"); @@ -3273,7 +3273,7 @@ impl<'a> Parser<'a> { if self.token != token::CloseDelim(token::Brace) { let token_str = self.this_token_to_string(); self.fatal(format!("expected `{}`, found `{}`", "}", - token_str)[]) + token_str).index(&FullRange)) } etc = true; break; @@ -3294,7 +3294,7 @@ impl<'a> Parser<'a> { BindByRef(..) | BindByValue(MutMutable) => { let token_str = self.this_token_to_string(); self.fatal(format!("unexpected `{}`", - token_str)[]) + token_str).index(&FullRange)) } _ => {} } @@ -3577,7 +3577,7 @@ impl<'a> Parser<'a> { let span = self.span; let tok_str = self.this_token_to_string(); self.span_fatal(span, - format!("expected identifier, found `{}`", tok_str)[]); + format!("expected identifier, found `{}`", tok_str).index(&FullRange)); } let ident = self.parse_ident(); let last_span = self.last_span; @@ -3674,7 +3674,7 @@ impl<'a> Parser<'a> { let lo = self.span.lo; if self.token.is_keyword(keywords::Let) { - check_expected_item(self, item_attrs[]); + check_expected_item(self, item_attrs.index(&FullRange)); self.expect_keyword(keywords::Let); let decl = self.parse_let(); P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))) @@ -3683,7 +3683,7 @@ impl<'a> Parser<'a> { && self.look_ahead(1, |t| *t == token::Not) { // it's a macro invocation: - check_expected_item(self, item_attrs[]); + check_expected_item(self, item_attrs.index(&FullRange)); // Potential trouble: if we allow macros with paths instead of // idents, we'd need to look ahead past the whole path here... @@ -3711,7 +3711,7 @@ impl<'a> Parser<'a> { let tok_str = self.this_token_to_string(); self.fatal(format!("expected {}`(` or `{{`, found `{}`", ident_str, - tok_str)[]) + tok_str).index(&FullRange)) }, }; @@ -3759,7 +3759,7 @@ impl<'a> Parser<'a> { } } else { let found_attrs = !item_attrs.is_empty(); - let item_err = Parser::expected_item_err(item_attrs[]); + let item_err = Parser::expected_item_err(item_attrs.index(&FullRange)); match self.parse_item_or_view_item(item_attrs, false) { IoviItem(i) => { let hi = i.span.hi; @@ -3803,7 +3803,7 @@ impl<'a> Parser<'a> { let sp = self.span; let tok = self.this_token_to_string(); self.span_fatal_help(sp, - format!("expected `{{`, found `{}`", tok)[], + format!("expected `{{`, found `{}`", tok).index(&FullRange), "place this code inside a block"); } @@ -3857,13 +3857,13 @@ impl<'a> Parser<'a> { while self.token != token::CloseDelim(token::Brace) { // parsing items even when they're not allowed lets us give // better error messages and recover more gracefully. - attributes_box.push_all(self.parse_outer_attributes()[]); + attributes_box.push_all(self.parse_outer_attributes().index(&FullRange)); match self.token { token::Semi => { if !attributes_box.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attributes_box[])); + Parser::expected_item_err(attributes_box.index(&FullRange))); attributes_box = Vec::new(); } self.bump(); // empty @@ -3955,7 +3955,7 @@ impl<'a> Parser<'a> { if !attributes_box.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attributes_box[])); + Parser::expected_item_err(attributes_box.index(&FullRange))); } let hi = self.span.hi; @@ -4399,7 +4399,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_string(); self.fatal(format!("expected `self`, found `{}`", - token_str)[]) + token_str).index(&FullRange)) } } } @@ -4553,7 +4553,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_string(); self.fatal(format!("expected `,` or `)`, found `{}`", - token_str)[]) + token_str).index(&FullRange)) } } } @@ -4729,7 +4729,7 @@ impl<'a> Parser<'a> { let (inner_attrs, body) = self.parse_inner_attrs_and_block(); let body_span = body.span; let mut new_attrs = attrs; - new_attrs.push_all(inner_attrs[]); + new_attrs.push_all(inner_attrs.index(&FullRange)); (ast::MethDecl(ident, generics, abi, @@ -4948,7 +4948,7 @@ impl<'a> Parser<'a> { if fields.len() == 0 { self.fatal(format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone()))[]); + token::get_ident(class_name.clone())).index(&FullRange)); } self.bump(); @@ -4987,7 +4987,7 @@ impl<'a> Parser<'a> { if fields.len() == 0 { self.fatal(format!("unit-like struct definition should be \ written as `struct {};`", - token::get_ident(class_name.clone()))[]); + token::get_ident(class_name.clone())).index(&FullRange)); } self.parse_where_clause(generics); @@ -5002,7 +5002,7 @@ impl<'a> Parser<'a> { } else { let token_str = self.this_token_to_string(); self.fatal(format!("expected `where`, `{}`, `(`, or `;` after struct \ - name, found `{}`", "{", token_str)[]); + name, found `{}`", "{", token_str).index(&FullRange)); } } @@ -5022,7 +5022,7 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_string(); self.span_fatal_help(span, format!("expected `,`, or `}}`, found `{}`", - token_str)[], + token_str).index(&FullRange), "struct fields should be separated by commas") } } @@ -5109,7 +5109,7 @@ impl<'a> Parser<'a> { let mut attrs = self.parse_outer_attributes(); if first { let mut tmp = attrs_remaining.clone(); - tmp.push_all(attrs[]); + tmp.push_all(attrs.index(&FullRange)); attrs = tmp; first = false; } @@ -5126,7 +5126,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_string(); self.fatal(format!("expected item, found `{}`", - token_str)[]) + token_str).index(&FullRange)) } } } @@ -5135,7 +5135,7 @@ impl<'a> Parser<'a> { // We parsed attributes for the first item but didn't find it let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attrs_remaining[])); + Parser::expected_item_err(attrs_remaining.index(&FullRange))); } ast::Mod { @@ -5205,7 +5205,7 @@ impl<'a> Parser<'a> { -> (ast::Item_, Vec ) { let mut prefix = Path::new(self.sess.span_diagnostic.cm.span_to_filename(self.span)); prefix.pop(); - let mod_path = Path::new(".").join_many(self.mod_path_stack[]); + let mod_path = Path::new(".").join_many(self.mod_path_stack.index(&FullRange)); let dir_path = prefix.join(&mod_path); let mod_string = token::get_ident(id); let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name( @@ -5215,8 +5215,8 @@ impl<'a> Parser<'a> { let mod_name = mod_string.get().to_string(); let default_path_str = format!("{}.rs", mod_name); let secondary_path_str = format!("{}/mod.rs", mod_name); - let default_path = dir_path.join(default_path_str[]); - let secondary_path = dir_path.join(secondary_path_str[]); + let default_path = dir_path.join(default_path_str.index(&FullRange)); + let secondary_path = dir_path.join(secondary_path_str.index(&FullRange)); let default_exists = default_path.exists(); let secondary_exists = secondary_path.exists(); @@ -5231,13 +5231,13 @@ impl<'a> Parser<'a> { format!("maybe move this module `{0}` \ to its own directory via \ `{0}/mod.rs`", - this_module)[]); + this_module).index(&FullRange)); if default_exists || secondary_exists { self.span_note(id_sp, format!("... or maybe `use` the module \ `{}` instead of possibly \ redeclaring it", - mod_name)[]); + mod_name).index(&FullRange)); } self.abort_if_errors(); } @@ -5248,12 +5248,12 @@ impl<'a> Parser<'a> { (false, false) => { self.span_fatal_help(id_sp, format!("file not found for module `{}`", - mod_name)[], + mod_name).index(&FullRange), format!("name the file either {} or {} inside \ the directory {}", default_path_str, secondary_path_str, - dir_path.display())[]); + dir_path.display()).index(&FullRange)); } (true, true) => { self.span_fatal_help( @@ -5262,7 +5262,7 @@ impl<'a> Parser<'a> { and {}", mod_name, default_path_str, - secondary_path_str)[], + secondary_path_str).index(&FullRange), "delete or rename one of them to remove the ambiguity"); } } @@ -5284,11 +5284,11 @@ impl<'a> Parser<'a> { let mut err = String::from_str("circular modules: "); let len = included_mod_stack.len(); for p in included_mod_stack.slice(i, len).iter() { - err.push_str(p.display().as_cow()[]); + err.push_str(p.display().as_cow().index(&FullRange)); err.push_str(" -> "); } - err.push_str(path.display().as_cow()[]); - self.span_fatal(id_sp, err[]); + err.push_str(path.display().as_cow().index(&FullRange)); + self.span_fatal(id_sp, err.index(&FullRange)); } None => () } @@ -5369,7 +5369,7 @@ impl<'a> Parser<'a> { if !attrs_remaining.is_empty() { let last_span = self.last_span; self.span_err(last_span, - Parser::expected_item_err(attrs_remaining[])); + Parser::expected_item_err(attrs_remaining.index(&FullRange))); } assert!(self.token == token::CloseDelim(token::Brace)); ast::ForeignMod { @@ -5410,7 +5410,7 @@ impl<'a> Parser<'a> { self.span_help(span, format!("perhaps you meant to enclose the crate name `{}` in \ a string?", - the_ident.as_str())[]); + the_ident.as_str()).index(&FullRange)); None } else { None @@ -5436,7 +5436,7 @@ impl<'a> Parser<'a> { self.span_fatal(span, format!("expected extern crate name but \ found `{}`", - token_str)[]); + token_str).index(&FullRange)); } }; @@ -5534,7 +5534,7 @@ impl<'a> Parser<'a> { self.span_err(start_span, format!("unit-like struct variant should be written \ without braces, as `{},`", - token::get_ident(ident))[]); + token::get_ident(ident)).index(&FullRange)); } kind = StructVariantKind(struct_def); } else if self.check(&token::OpenDelim(token::Paren)) { @@ -5619,7 +5619,7 @@ impl<'a> Parser<'a> { format!("illegal ABI: expected one of [{}], \ found `{}`", abi::all_names().connect(", "), - the_string)[]); + the_string).index(&FullRange)); None } } @@ -5681,7 +5681,7 @@ impl<'a> Parser<'a> { format!("`extern mod` is obsolete, use \ `extern crate` instead \ to refer to external \ - crates.")[]) + crates.").index(&FullRange)) } return self.parse_item_extern_crate(lo, visibility, attrs); } @@ -5709,7 +5709,7 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_string(); self.span_fatal(span, format!("expected `{}` or `fn`, found `{}`", "{", - token_str)[]); + token_str).index(&FullRange)); } if self.eat_keyword(keywords::Virtual) { @@ -5822,7 +5822,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Mod) { // MODULE ITEM let (ident, item_, extra_attrs) = - self.parse_item_mod(attrs[]); + self.parse_item_mod(attrs.index(&FullRange)); let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -6162,7 +6162,7 @@ impl<'a> Parser<'a> { macros_allowed: bool) -> ParsedItemsAndViewItems { let mut attrs = first_item_attrs; - attrs.push_all(self.parse_outer_attributes()[]); + attrs.push_all(self.parse_outer_attributes().index(&FullRange)); // First, parse view items. let mut view_items : Vec = Vec::new(); let mut items = Vec::new(); @@ -6244,7 +6244,7 @@ impl<'a> Parser<'a> { macros_allowed: bool) -> ParsedItemsAndViewItems { let mut attrs = first_item_attrs; - attrs.push_all(self.parse_outer_attributes()[]); + attrs.push_all(self.parse_outer_attributes().index(&FullRange)); let mut foreign_items = Vec::new(); loop { match self.parse_foreign_item(attrs, macros_allowed) { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 094aacf3207fc..ca683a5647246 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -479,7 +479,7 @@ macro_rules! declare_special_idents_and_keywords {( $(init_vec.push($si_str);)* $(init_vec.push($sk_str);)* $(init_vec.push($rk_str);)* - interner::StrInterner::prefill(init_vec[]) + interner::StrInterner::prefill(init_vec.index(&FullRange)) } }} @@ -628,7 +628,7 @@ impl InternedString { #[inline] pub fn get<'a>(&'a self) -> &'a str { - self.string[] + self.string.index(&FullRange) } } @@ -652,29 +652,29 @@ impl BytesContainer for InternedString { impl fmt::Show for InternedString { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.string[]) + write!(f, "{}", self.string.index(&FullRange)) } } impl<'a> PartialEq<&'a str> for InternedString { #[inline(always)] fn eq(&self, other: & &'a str) -> bool { - PartialEq::eq(self.string[], *other) + PartialEq::eq(self.string.index(&FullRange), *other) } #[inline(always)] fn ne(&self, other: & &'a str) -> bool { - PartialEq::ne(self.string[], *other) + PartialEq::ne(self.string.index(&FullRange), *other) } } impl<'a> PartialEq for &'a str { #[inline(always)] fn eq(&self, other: &InternedString) -> bool { - PartialEq::eq(*self, other.string[]) + PartialEq::eq(*self, other.string.index(&FullRange)) } #[inline(always)] fn ne(&self, other: &InternedString) -> bool { - PartialEq::ne(*self, other.string[]) + PartialEq::ne(*self, other.string.index(&FullRange)) } } @@ -682,7 +682,7 @@ impl<'a> PartialEq for &'a str { impl, E> Decodable for InternedString { fn decode(d: &mut D) -> Result { Ok(get_name(get_ident_interner().intern( - try!(d.read_str())[]))) + try!(d.read_str()).index(&FullRange)))) } } @@ -697,7 +697,7 @@ impl Decodable for InternedString { #[cfg(stage0)] impl, E> Encodable for InternedString { fn encode(&self, s: &mut S) -> Result<(), E> { - s.emit_str(self.string[]) + s.emit_str(self.string.index(&FullRange)) } } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 11cefc8719bab..52306075c21ec 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -140,7 +140,7 @@ pub fn buf_str(toks: Vec, } s.push_str(format!("{}={}", szs[i], - tok_str(toks[i].clone()))[]); + tok_str(toks[i].clone())).index(&FullRange)); i += 1u; i %= n; } @@ -602,7 +602,7 @@ impl Printer { assert_eq!(l, len); // assert!(l <= space); self.space -= len; - self.print_str(s[]) + self.print_str(s.index(&FullRange)) } Eof => { // Eof should never get here. diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 402583b60fae5..9a38f6c8ac325 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -114,7 +114,7 @@ pub fn print_crate<'a>(cm: &'a CodeMap, out, ann, is_expanded); - try!(s.print_mod(&krate.module, krate.attrs[])); + try!(s.print_mod(&krate.module, krate.attrs.index(&FullRange))); try!(s.print_remaining_comments()); eof(&mut s.s) } @@ -580,7 +580,7 @@ impl<'a> State<'a> { pub fn synth_comment(&mut self, text: String) -> IoResult<()> { try!(word(&mut self.s, "/*")); try!(space(&mut self.s)); - try!(word(&mut self.s, text[])); + try!(word(&mut self.s, text.index(&FullRange))); try!(space(&mut self.s)); word(&mut self.s, "*/") } @@ -685,7 +685,7 @@ impl<'a> State<'a> { } ast::TyTup(ref elts) => { try!(self.popen()); - try!(self.commasep(Inconsistent, elts[], + try!(self.commasep(Inconsistent, elts.index(&FullRange), |s, ty| s.print_type(&**ty))); if elts.len() == 1 { try!(word(&mut self.s, ",")); @@ -721,10 +721,10 @@ impl<'a> State<'a> { } ast::TyObjectSum(ref ty, ref bounds) => { try!(self.print_type(&**ty)); - try!(self.print_bounds("+", bounds[])); + try!(self.print_bounds("+", bounds.index(&FullRange))); } ast::TyPolyTraitRef(ref bounds) => { - try!(self.print_bounds("", bounds[])); + try!(self.print_bounds("", bounds.index(&FullRange))); } ast::TyQPath(ref qpath) => { try!(word(&mut self.s, "<")); @@ -759,7 +759,7 @@ impl<'a> State<'a> { item: &ast::ForeignItem) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs[])); + try!(self.print_outer_attributes(item.attrs.index(&FullRange))); match item.node { ast::ForeignItemFn(ref decl, ref generics) => { try!(self.print_fn(&**decl, None, abi::Rust, item.ident, generics, @@ -770,7 +770,7 @@ impl<'a> State<'a> { } ast::ForeignItemStatic(ref t, m) => { try!(self.head(visibility_qualified(item.vis, - "static")[])); + "static").index(&FullRange))); if m { try!(self.word_space("mut")); } @@ -787,7 +787,7 @@ impl<'a> State<'a> { fn print_associated_type(&mut self, typedef: &ast::AssociatedType) -> IoResult<()> { - try!(self.print_outer_attributes(typedef.attrs[])); + try!(self.print_outer_attributes(typedef.attrs.index(&FullRange))); try!(self.word_space("type")); try!(self.print_ty_param(&typedef.ty_param)); word(&mut self.s, ";") @@ -806,12 +806,12 @@ impl<'a> State<'a> { pub fn print_item(&mut self, item: &ast::Item) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs[])); + try!(self.print_outer_attributes(item.attrs.index(&FullRange))); try!(self.ann.pre(self, NodeItem(item))); match item.node { ast::ItemStatic(ref ty, m, ref expr) => { try!(self.head(visibility_qualified(item.vis, - "static")[])); + "static").index(&FullRange))); if m == ast::MutMutable { try!(self.word_space("mut")); } @@ -828,7 +828,7 @@ impl<'a> State<'a> { } ast::ItemConst(ref ty, ref expr) => { try!(self.head(visibility_qualified(item.vis, - "const")[])); + "const").index(&FullRange))); try!(self.print_ident(item.ident)); try!(self.word_space(":")); try!(self.print_type(&**ty)); @@ -851,29 +851,29 @@ impl<'a> State<'a> { item.vis )); try!(word(&mut self.s, " ")); - try!(self.print_block_with_attrs(&**body, item.attrs[])); + try!(self.print_block_with_attrs(&**body, item.attrs.index(&FullRange))); } ast::ItemMod(ref _mod) => { try!(self.head(visibility_qualified(item.vis, - "mod")[])); + "mod").index(&FullRange))); try!(self.print_ident(item.ident)); try!(self.nbsp()); try!(self.bopen()); - try!(self.print_mod(_mod, item.attrs[])); + try!(self.print_mod(_mod, item.attrs.index(&FullRange))); try!(self.bclose(item.span)); } ast::ItemForeignMod(ref nmod) => { try!(self.head("extern")); - try!(self.word_nbsp(nmod.abi.to_string()[])); + try!(self.word_nbsp(nmod.abi.to_string().index(&FullRange))); try!(self.bopen()); - try!(self.print_foreign_mod(nmod, item.attrs[])); + try!(self.print_foreign_mod(nmod, item.attrs.index(&FullRange))); try!(self.bclose(item.span)); } ast::ItemTy(ref ty, ref params) => { try!(self.ibox(indent_unit)); try!(self.ibox(0u)); try!(self.word_nbsp(visibility_qualified(item.vis, - "type")[])); + "type").index(&FullRange))); try!(self.print_ident(item.ident)); try!(self.print_generics(params)); try!(self.end()); // end the inner ibox @@ -895,7 +895,7 @@ impl<'a> State<'a> { )); } ast::ItemStruct(ref struct_def, ref generics) => { - try!(self.head(visibility_qualified(item.vis,"struct")[])); + try!(self.head(visibility_qualified(item.vis,"struct").index(&FullRange))); try!(self.print_struct(&**struct_def, generics, item.ident, item.span)); } @@ -936,7 +936,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.bopen()); - try!(self.print_inner_attributes(item.attrs[])); + try!(self.print_inner_attributes(item.attrs.index(&FullRange))); for impl_item in impl_items.iter() { match *impl_item { ast::MethodImplItem(ref meth) => { @@ -967,7 +967,7 @@ impl<'a> State<'a> { real_bounds.push(b); } } - try!(self.print_bounds(":", real_bounds[])); + try!(self.print_bounds(":", real_bounds.index(&FullRange))); try!(self.print_where_clause(generics)); try!(word(&mut self.s, " ")); try!(self.bopen()); @@ -985,7 +985,7 @@ impl<'a> State<'a> { try!(self.print_ident(item.ident)); try!(self.cbox(indent_unit)); try!(self.popen()); - try!(self.print_tts(tts[])); + try!(self.print_tts(tts.index(&FullRange))); try!(self.pclose()); try!(word(&mut self.s, ";")); try!(self.end()); @@ -1019,12 +1019,12 @@ impl<'a> State<'a> { generics: &ast::Generics, ident: ast::Ident, span: codemap::Span, visibility: ast::Visibility) -> IoResult<()> { - try!(self.head(visibility_qualified(visibility, "enum")[])); + try!(self.head(visibility_qualified(visibility, "enum").index(&FullRange))); try!(self.print_ident(ident)); try!(self.print_generics(generics)); try!(self.print_where_clause(generics)); try!(space(&mut self.s)); - self.print_variants(enum_definition.variants[], span) + self.print_variants(enum_definition.variants.index(&FullRange), span) } pub fn print_variants(&mut self, @@ -1034,7 +1034,7 @@ impl<'a> State<'a> { for v in variants.iter() { try!(self.space_if_not_bol()); try!(self.maybe_print_comment(v.span.lo)); - try!(self.print_outer_attributes(v.node.attrs[])); + try!(self.print_outer_attributes(v.node.attrs.index(&FullRange))); try!(self.ibox(indent_unit)); try!(self.print_variant(&**v)); try!(word(&mut self.s, ",")); @@ -1062,7 +1062,7 @@ impl<'a> State<'a> { if !struct_def.fields.is_empty() { try!(self.popen()); try!(self.commasep( - Inconsistent, struct_def.fields[], + Inconsistent, struct_def.fields.index(&FullRange), |s, field| { match field.node.kind { ast::NamedField(..) => panic!("unexpected named field"), @@ -1092,7 +1092,7 @@ impl<'a> State<'a> { ast::NamedField(ident, visibility) => { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(field.span.lo)); - try!(self.print_outer_attributes(field.node.attrs[])); + try!(self.print_outer_attributes(field.node.attrs.index(&FullRange))); try!(self.print_visibility(visibility)); try!(self.print_ident(ident)); try!(self.word_nbsp(":")); @@ -1116,7 +1116,7 @@ impl<'a> State<'a> { pub fn print_tt(&mut self, tt: &ast::TokenTree) -> IoResult<()> { match *tt { ast::TtToken(_, ref tk) => { - try!(word(&mut self.s, token_to_string(tk)[])); + try!(word(&mut self.s, token_to_string(tk).index(&FullRange))); match *tk { parse::token::DocComment(..) => { hardbreak(&mut self.s) @@ -1125,11 +1125,11 @@ impl<'a> State<'a> { } } ast::TtDelimited(_, ref delimed) => { - try!(word(&mut self.s, token_to_string(&delimed.open_token())[])); + try!(word(&mut self.s, token_to_string(&delimed.open_token()).index(&FullRange))); try!(space(&mut self.s)); - try!(self.print_tts(delimed.tts[])); + try!(self.print_tts(delimed.tts.index(&FullRange))); try!(space(&mut self.s)); - word(&mut self.s, token_to_string(&delimed.close_token())[]) + word(&mut self.s, token_to_string(&delimed.close_token()).index(&FullRange)) }, ast::TtSequence(_, ref seq) => { try!(word(&mut self.s, "$(")); @@ -1139,7 +1139,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, ")")); match seq.separator { Some(ref tk) => { - try!(word(&mut self.s, token_to_string(tk)[])); + try!(word(&mut self.s, token_to_string(tk).index(&FullRange))); } None => {}, } @@ -1170,7 +1170,7 @@ impl<'a> State<'a> { if !args.is_empty() { try!(self.popen()); try!(self.commasep(Consistent, - args[], + args.index(&FullRange), |s, arg| s.print_type(&*arg.ty))); try!(self.pclose()); } @@ -1194,7 +1194,7 @@ impl<'a> State<'a> { pub fn print_ty_method(&mut self, m: &ast::TypeMethod) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(m.span.lo)); - try!(self.print_outer_attributes(m.attrs[])); + try!(self.print_outer_attributes(m.attrs.index(&FullRange))); try!(self.print_ty_fn(None, None, m.unsafety, @@ -1226,7 +1226,7 @@ impl<'a> State<'a> { pub fn print_method(&mut self, meth: &ast::Method) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(meth.span.lo)); - try!(self.print_outer_attributes(meth.attrs[])); + try!(self.print_outer_attributes(meth.attrs.index(&FullRange))); match meth.node { ast::MethDecl(ident, ref generics, @@ -1244,7 +1244,7 @@ impl<'a> State<'a> { Some(&explicit_self.node), vis)); try!(word(&mut self.s, " ")); - self.print_block_with_attrs(&**body, meth.attrs[]) + self.print_block_with_attrs(&**body, meth.attrs.index(&FullRange)) }, ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _), ..}) => { @@ -1253,7 +1253,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "! ")); try!(self.cbox(indent_unit)); try!(self.popen()); - try!(self.print_tts(tts[])); + try!(self.print_tts(tts.index(&FullRange))); try!(self.pclose()); try!(word(&mut self.s, ";")); self.end() @@ -1520,7 +1520,7 @@ impl<'a> State<'a> { ast::ExprVec(ref exprs) => { try!(self.ibox(indent_unit)); try!(word(&mut self.s, "[")); - try!(self.commasep_exprs(Inconsistent, exprs[])); + try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange))); try!(word(&mut self.s, "]")); try!(self.end()); } @@ -1540,7 +1540,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "{")); try!(self.commasep_cmnt( Consistent, - fields[], + fields.index(&FullRange), |s, field| { try!(s.ibox(indent_unit)); try!(s.print_ident(field.ident.node)); @@ -1566,7 +1566,7 @@ impl<'a> State<'a> { } ast::ExprTup(ref exprs) => { try!(self.popen()); - try!(self.commasep_exprs(Inconsistent, exprs[])); + try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange))); if exprs.len() == 1 { try!(word(&mut self.s, ",")); } @@ -1574,7 +1574,7 @@ impl<'a> State<'a> { } ast::ExprCall(ref func, ref args) => { try!(self.print_expr_maybe_paren(&**func)); - try!(self.print_call_post(args[])); + try!(self.print_call_post(args.index(&FullRange))); } ast::ExprMethodCall(ident, ref tys, ref args) => { let base_args = args.slice_from(1); @@ -1583,7 +1583,7 @@ impl<'a> State<'a> { try!(self.print_ident(ident.node)); if tys.len() > 0u { try!(word(&mut self.s, "::<")); - try!(self.commasep(Inconsistent, tys[], + try!(self.commasep(Inconsistent, tys.index(&FullRange), |s, ty| s.print_type(&**ty))); try!(word(&mut self.s, ">")); } @@ -1780,11 +1780,11 @@ impl<'a> State<'a> { try!(self.print_string(a.asm.get(), a.asm_str_style)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.outputs[], + try!(self.commasep(Inconsistent, a.outputs.index(&FullRange), |s, &(ref co, ref o, is_rw)| { match co.get().slice_shift_char() { Some(('=', operand)) if is_rw => { - try!(s.print_string(format!("+{}", operand)[], + try!(s.print_string(format!("+{}", operand).index(&FullRange), ast::CookedStr)) } _ => try!(s.print_string(co.get(), ast::CookedStr)) @@ -1797,7 +1797,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.inputs[], + try!(self.commasep(Inconsistent, a.inputs.index(&FullRange), |s, &(ref co, ref o)| { try!(s.print_string(co.get(), ast::CookedStr)); try!(s.popen()); @@ -1808,7 +1808,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); try!(self.word_space(":")); - try!(self.commasep(Inconsistent, a.clobbers[], + try!(self.commasep(Inconsistent, a.clobbers.index(&FullRange), |s, co| { try!(s.print_string(co.get(), ast::CookedStr)); Ok(()) @@ -1882,7 +1882,7 @@ impl<'a> State<'a> { pub fn print_ident(&mut self, ident: ast::Ident) -> IoResult<()> { if self.encode_idents_with_hygiene { let encoded = ident.encode_with_hygiene(); - try!(word(&mut self.s, encoded[])) + try!(word(&mut self.s, encoded.index(&FullRange))) } else { try!(word(&mut self.s, token::get_ident(ident).get())) } @@ -1890,7 +1890,7 @@ impl<'a> State<'a> { } pub fn print_uint(&mut self, i: uint) -> IoResult<()> { - word(&mut self.s, i.to_string()[]) + word(&mut self.s, i.to_string().index(&FullRange)) } pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> { @@ -1964,7 +1964,7 @@ impl<'a> State<'a> { } try!(self.commasep( Inconsistent, - data.types[], + data.types.index(&FullRange), |s, ty| s.print_type(&**ty))); comma = true; } @@ -1987,7 +1987,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "(")); try!(self.commasep( Inconsistent, - data.inputs[], + data.inputs.index(&FullRange), |s, ty| s.print_type(&**ty))); try!(word(&mut self.s, ")")); @@ -2040,7 +2040,7 @@ impl<'a> State<'a> { Some(ref args) => { if !args.is_empty() { try!(self.popen()); - try!(self.commasep(Inconsistent, args[], + try!(self.commasep(Inconsistent, args.index(&FullRange), |s, p| s.print_pat(&**p))); try!(self.pclose()); } @@ -2052,7 +2052,7 @@ impl<'a> State<'a> { try!(self.nbsp()); try!(self.word_space("{")); try!(self.commasep_cmnt( - Consistent, fields[], + Consistent, fields.index(&FullRange), |s, f| { try!(s.cbox(indent_unit)); if !f.node.is_shorthand { @@ -2073,7 +2073,7 @@ impl<'a> State<'a> { ast::PatTup(ref elts) => { try!(self.popen()); try!(self.commasep(Inconsistent, - elts[], + elts.index(&FullRange), |s, p| s.print_pat(&**p))); if elts.len() == 1 { try!(word(&mut self.s, ",")); @@ -2101,7 +2101,7 @@ impl<'a> State<'a> { ast::PatVec(ref before, ref slice, ref after) => { try!(word(&mut self.s, "[")); try!(self.commasep(Inconsistent, - before[], + before.index(&FullRange), |s, p| s.print_pat(&**p))); for p in slice.iter() { if !before.is_empty() { try!(self.word_space(",")); } @@ -2115,7 +2115,7 @@ impl<'a> State<'a> { if !after.is_empty() { try!(self.word_space(",")); } } try!(self.commasep(Inconsistent, - after[], + after.index(&FullRange), |s, p| s.print_pat(&**p))); try!(word(&mut self.s, "]")); } @@ -2132,7 +2132,7 @@ impl<'a> State<'a> { } try!(self.cbox(indent_unit)); try!(self.ibox(0u)); - try!(self.print_outer_attributes(arm.attrs[])); + try!(self.print_outer_attributes(arm.attrs.index(&FullRange))); let mut first = true; for p in arm.pats.iter() { if first { @@ -2232,7 +2232,7 @@ impl<'a> State<'a> { // HACK(eddyb) ignore the separately printed self argument. let args = if first { - decl.inputs[] + decl.inputs.index(&FullRange) } else { decl.inputs.slice_from(1) }; @@ -2398,7 +2398,7 @@ impl<'a> State<'a> { ints.push(i); } - try!(self.commasep(Inconsistent, ints[], |s, &idx| { + try!(self.commasep(Inconsistent, ints.index(&FullRange), |s, &idx| { if idx < generics.lifetimes.len() { let lifetime = &generics.lifetimes[idx]; s.print_lifetime_def(lifetime) @@ -2415,7 +2415,7 @@ impl<'a> State<'a> { pub fn print_ty_param(&mut self, param: &ast::TyParam) -> IoResult<()> { try!(self.print_ident(param.ident)); - try!(self.print_bounds(":", param.bounds[])); + try!(self.print_bounds(":", param.bounds.index(&FullRange))); match param.default { Some(ref default) => { try!(space(&mut self.s)); @@ -2491,7 +2491,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, name.get())); try!(self.popen()); try!(self.commasep(Consistent, - items[], + items.index(&FullRange), |s, i| s.print_meta_item(&**i))); try!(self.pclose()); } @@ -2527,7 +2527,7 @@ impl<'a> State<'a> { try!(self.print_path(path, false)); try!(word(&mut self.s, "::{")); } - try!(self.commasep(Inconsistent, idents[], |s, w| { + try!(self.commasep(Inconsistent, idents.index(&FullRange), |s, w| { match w.node { ast::PathListIdent { name, .. } => { s.print_ident(name) @@ -2545,7 +2545,7 @@ impl<'a> State<'a> { pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> { try!(self.hardbreak_if_not_bol()); try!(self.maybe_print_comment(item.span.lo)); - try!(self.print_outer_attributes(item.attrs[])); + try!(self.print_outer_attributes(item.attrs.index(&FullRange))); try!(self.print_visibility(item.vis)); match item.node { ast::ViewItemExternCrate(id, ref optional_path, _) => { @@ -2687,7 +2687,7 @@ impl<'a> State<'a> { try!(self.pclose()); } - try!(self.print_bounds(":", bounds[])); + try!(self.print_bounds(":", bounds.index(&FullRange))); try!(self.print_fn_output(decl)); @@ -2746,7 +2746,7 @@ impl<'a> State<'a> { try!(self.maybe_print_comment(lit.span.lo)); match self.next_lit(lit.span.lo) { Some(ref ltrl) => { - return word(&mut self.s, (*ltrl).lit[]); + return word(&mut self.s, (*ltrl).lit.index(&FullRange)); } _ => () } @@ -2756,7 +2756,7 @@ impl<'a> State<'a> { let mut res = String::from_str("b'"); ascii::escape_default(byte, |c| res.push(c as char)); res.push('\''); - word(&mut self.s, res[]) + word(&mut self.s, res.index(&FullRange)) } ast::LitChar(ch) => { let mut res = String::from_str("'"); @@ -2764,27 +2764,27 @@ impl<'a> State<'a> { res.push(c); } res.push('\''); - word(&mut self.s, res[]) + word(&mut self.s, res.index(&FullRange)) } ast::LitInt(i, t) => { match t { ast::SignedIntLit(st, ast::Plus) => { word(&mut self.s, - ast_util::int_ty_to_string(st, Some(i as i64))[]) + ast_util::int_ty_to_string(st, Some(i as i64)).index(&FullRange)) } ast::SignedIntLit(st, ast::Minus) => { let istr = ast_util::int_ty_to_string(st, Some(-(i as i64))); word(&mut self.s, - format!("-{}", istr)[]) + format!("-{}", istr).index(&FullRange)) } ast::UnsignedIntLit(ut) => { - word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i))[]) + word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i)).index(&FullRange)) } ast::UnsuffixedIntLit(ast::Plus) => { - word(&mut self.s, format!("{}", i)[]) + word(&mut self.s, format!("{}", i).index(&FullRange)) } ast::UnsuffixedIntLit(ast::Minus) => { - word(&mut self.s, format!("-{}", i)[]) + word(&mut self.s, format!("-{}", i).index(&FullRange)) } } } @@ -2793,7 +2793,7 @@ impl<'a> State<'a> { format!( "{}{}", f.get(), - ast_util::float_ty_to_string(t)[])[]) + ast_util::float_ty_to_string(t).index(&FullRange)).index(&FullRange)) } ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()), ast::LitBool(val) => { @@ -2805,7 +2805,7 @@ impl<'a> State<'a> { ascii::escape_default(ch as u8, |ch| escaped.push(ch as char)); } - word(&mut self.s, format!("b\"{}\"", escaped)[]) + word(&mut self.s, format!("b\"{}\"", escaped).index(&FullRange)) } } } @@ -2846,7 +2846,7 @@ impl<'a> State<'a> { comments::Mixed => { assert_eq!(cmnt.lines.len(), 1u); try!(zerobreak(&mut self.s)); - try!(word(&mut self.s, cmnt.lines[0][])); + try!(word(&mut self.s, cmnt.lines[0].index(&FullRange))); zerobreak(&mut self.s) } comments::Isolated => { @@ -2855,7 +2855,7 @@ impl<'a> State<'a> { // Don't print empty lines because they will end up as trailing // whitespace if !line.is_empty() { - try!(word(&mut self.s, line[])); + try!(word(&mut self.s, line.index(&FullRange))); } try!(hardbreak(&mut self.s)); } @@ -2864,13 +2864,13 @@ impl<'a> State<'a> { comments::Trailing => { try!(word(&mut self.s, " ")); if cmnt.lines.len() == 1u { - try!(word(&mut self.s, cmnt.lines[0][])); + try!(word(&mut self.s, cmnt.lines[0].index(&FullRange))); hardbreak(&mut self.s) } else { try!(self.ibox(0u)); for line in cmnt.lines.iter() { if !line.is_empty() { - try!(word(&mut self.s, line[])); + try!(word(&mut self.s, line.index(&FullRange))); } try!(hardbreak(&mut self.s)); } @@ -2903,7 +2903,7 @@ impl<'a> State<'a> { string=st)) } }; - word(&mut self.s, st[]) + word(&mut self.s, st.index(&FullRange)) } pub fn next_comment(&mut self) -> Option { @@ -2934,7 +2934,7 @@ impl<'a> State<'a> { Some(abi::Rust) => Ok(()), Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_string()[]) + self.word_nbsp(abi.to_string().index(&FullRange)) } None => Ok(()) } @@ -2945,7 +2945,7 @@ impl<'a> State<'a> { match opt_abi { Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_string()[]) + self.word_nbsp(abi.to_string().index(&FullRange)) } None => Ok(()) } @@ -2961,7 +2961,7 @@ impl<'a> State<'a> { if abi != abi::Rust { try!(self.word_nbsp("extern")); - try!(self.word_nbsp(abi.to_string()[])); + try!(self.word_nbsp(abi.to_string().index(&FullRange))); } word(&mut self.s, "fn") diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index 4ef7eb97a2189..daa51203287b3 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -40,7 +40,7 @@ pub fn maybe_inject_prelude(krate: ast::Crate) -> ast::Crate { } fn use_std(krate: &ast::Crate) -> bool { - !attr::contains_name(krate.attrs[], "no_std") + !attr::contains_name(krate.attrs.index(&FullRange), "no_std") } fn no_prelude(attrs: &[ast::Attribute]) -> bool { @@ -56,7 +56,7 @@ impl<'a> fold::Folder for StandardLibraryInjector<'a> { // The name to use in `extern crate "name" as std;` let actual_crate_name = match self.alt_std_name { - Some(ref s) => token::intern_and_get_ident(s[]), + Some(ref s) => token::intern_and_get_ident(s.index(&FullRange)), None => token::intern_and_get_ident("std"), }; @@ -104,7 +104,7 @@ impl<'a> fold::Folder for PreludeInjector<'a> { attr::mark_used(&no_std_attr); krate.attrs.push(no_std_attr); - if !no_prelude(krate.attrs[]) { + if !no_prelude(krate.attrs.index(&FullRange)) { // only add `use std::prelude::*;` if there wasn't a // `#![no_implicit_prelude]` at the crate level. // fold_mod() will insert glob path. @@ -124,7 +124,7 @@ impl<'a> fold::Folder for PreludeInjector<'a> { } fn fold_item(&mut self, item: P) -> SmallVector> { - if !no_prelude(item.attrs[]) { + if !no_prelude(item.attrs.index(&FullRange)) { // only recur if there wasn't `#![no_implicit_prelude]` // on this item, i.e. this means that the prelude is not // implicitly imported though the whole subtree diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index e480532a41053..0b2c45ee3a779 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -73,14 +73,14 @@ pub fn modify_for_testing(sess: &ParseSess, // We generate the test harness when building in the 'test' // configuration, either with the '--test' or '--cfg test' // command line options. - let should_test = attr::contains_name(krate.config[], "test"); + let should_test = attr::contains_name(krate.config.index(&FullRange), "test"); // Check for #[reexport_test_harness_main = "some_name"] which // creates a `use some_name = __test::main;`. This needs to be // unconditional, so that the attribute is still marked as used in // non-test builds. let reexport_test_harness_main = - attr::first_attr_value_str_by_name(krate.attrs[], + attr::first_attr_value_str_by_name(krate.attrs.index(&FullRange), "reexport_test_harness_main"); if should_test { @@ -119,7 +119,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { self.cx.path.push(ident); } debug!("current path: {}", - ast_util::path_name_i(self.cx.path[])); + ast_util::path_name_i(self.cx.path.index(&FullRange))); if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) { match i.node { @@ -277,8 +277,8 @@ fn strip_test_functions(krate: ast::Crate) -> ast::Crate { // When not compiling with --test we should not compile the // #[test] functions config::strip_items(krate, |attrs| { - !attr::contains_name(attrs[], "test") && - !attr::contains_name(attrs[], "bench") + !attr::contains_name(attrs.index(&FullRange), "test") && + !attr::contains_name(attrs.index(&FullRange), "bench") }) } @@ -291,7 +291,7 @@ enum HasTestSignature { fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { - let has_test_attr = attr::contains_name(i.attrs[], "test"); + let has_test_attr = attr::contains_name(i.attrs.index(&FullRange), "test"); fn has_test_signature(i: &ast::Item) -> HasTestSignature { match &i.node { @@ -329,7 +329,7 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { } fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool { - let has_bench_attr = attr::contains_name(i.attrs[], "bench"); + let has_bench_attr = attr::contains_name(i.attrs.index(&FullRange), "bench"); fn has_test_signature(i: &ast::Item) -> bool { match i.node { @@ -384,7 +384,7 @@ We're going to be building a module that looks more or less like: mod __test { extern crate test (name = "test", vers = "..."); fn main() { - test::test_main_static(::os::args()[], tests) + test::test_main_static(::os::args().index(&FullRange), tests) } static tests : &'static [test::TestDescAndFn] = &[ @@ -510,8 +510,8 @@ fn mk_tests(cx: &TestCtxt) -> P { } fn is_test_crate(krate: &ast::Crate) -> bool { - match attr::find_crate_name(krate.attrs[]) { - Some(ref s) if "test" == s.get()[] => true, + match attr::find_crate_name(krate.attrs.index(&FullRange)) { + Some(ref s) if "test" == s.get().index(&FullRange) => true, _ => false } } @@ -551,11 +551,11 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P { // creates $name: $expr let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr); - debug!("encoding {}", ast_util::path_name_i(path[])); + debug!("encoding {}", ast_util::path_name_i(path.index(&FullRange))); // path to the #[test] function: "foo::bar::baz" - let path_string = ast_util::path_name_i(path[]); - let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string[])); + let path_string = ast_util::path_name_i(path.index(&FullRange)); + let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string.index(&FullRange))); // self::test::StaticTestName($name_expr) let name_expr = ecx.expr_call(span, diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 85eea2d9daf27..93de342d487dc 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -28,7 +28,7 @@ pub struct Interner { vect: RefCell >, } -// when traits can extend traits, we should extend index to get [] +// when traits can extend traits, we should extend index to get .index(&FullRange) impl Interner { pub fn new() -> Interner { Interner { @@ -109,27 +109,27 @@ impl Eq for RcStr {} impl Ord for RcStr { fn cmp(&self, other: &RcStr) -> Ordering { - self[].cmp(other[]) + self.index(&FullRange).cmp(other.index(&FullRange)) } } impl fmt::Show for RcStr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use std::fmt::Show; - self[].fmt(f) + self.index(&FullRange).fmt(f) } } impl BorrowFrom for str { fn borrow_from(owned: &RcStr) -> &str { - owned.string[] + owned.string.index(&FullRange) } } impl Deref for RcStr { type Target = str; - fn deref(&self) -> &str { self.string[] } + fn deref(&self) -> &str { self.string.index(&FullRange) } } /// A StrInterner differs from Interner in that it accepts @@ -139,7 +139,7 @@ pub struct StrInterner { vect: RefCell >, } -/// When traits can extend traits, we should extend index to get [] +/// When traits can extend traits, we should extend index to get .index(&FullRange) impl StrInterner { pub fn new() -> StrInterner { StrInterner { diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index 80d195d921846..71c71017850f2 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -180,7 +180,7 @@ impl TerminfoTerminal { } }; - let entry = open(term[]); + let entry = open(term.index(&FullRange)); if entry.is_err() { if os::getenv("MSYSCON").map_or(false, |s| { "mintty.exe" == s diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs index 5f0111c7d7a84..4617be4f3f63c 100644 --- a/src/libterm/terminfo/parser/compiled.rs +++ b/src/libterm/terminfo/parser/compiled.rs @@ -284,13 +284,13 @@ pub fn parse(file: &mut io::Reader, longnames: bool) // Find the offset of the NUL we want to go to - let nulpos = string_table[offset as uint .. string_table_bytes as uint] + let nulpos = string_table.index(&((offset as uint) .. (string_table_bytes as uint))) .iter().position(|&b| b == 0); match nulpos { Some(len) => { string_map.insert(name.to_string(), - string_table[offset as uint .. - offset as uint + len].to_vec()) + string_table.index(&((offset as uint) .. + (offset as uint + len))).to_vec()) }, None => { return Err("invalid file: missing NUL in \ diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index 395fac52d8dac..38be68600798e 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -61,13 +61,13 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { for p in dirs_to_search.iter() { if p.exists() { let f = first_char.to_string(); - let newp = p.join_many(&[f[], term]); + let newp = p.join_many(&[f.index(&FullRange), term]); if newp.exists() { return Some(box newp); } // on some installations the dir is named after the hex of the char (e.g. OS X) let f = format!("{:x}", first_char as uint); - let newp = p.join_many(&[f[], term]); + let newp = p.join_many(&[f.index(&FullRange), term]); if newp.exists() { return Some(box newp); } diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index c417fd94e22eb..76df9ea45610d 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -952,7 +952,7 @@ fn should_sort_failures_before_printing_them() { st.write_failures().unwrap(); let s = match st.out { - Raw(ref m) => String::from_utf8_lossy(m[]), + Raw(ref m) => String::from_utf8_lossy(m.index(&FullRange)), Pretty(_) => unreachable!() }; diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index bbbfb0051f99b..7109dc7948ed5 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -130,7 +130,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { copy_memory(buf.as_mut_slice(), alu); let buf_len = buf.len(); copy_memory(buf.slice_mut(alu_len, buf_len), - alu[..LINE_LEN]); + alu.index(&(0..LINE_LEN))); let mut pos = 0; let mut bytes; @@ -206,7 +206,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> { for i in range(0u, chars_left) { buf[i] = self.nextc(); } - self.out.write(buf[..chars_left]) + self.out.write(buf.index(&(0..chars_left))) } } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 28d7488c9bf8f..65127868b8788 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -247,14 +247,14 @@ fn generate_frequencies(mut input: &[u8], frame: uint) -> Table { // Pull first frame. for _ in range(0, frame) { code = code.push_char(input[0]); - input = input[1..]; + input = input.index(&(1..)); } frequencies.lookup(code, BumpCallback); while input.len() != 0 && input[0] != ('>' as u8) { code = code.rotate(input[0], frame); frequencies.lookup(code, BumpCallback); - input = input[1..]; + input = input.index(&(1..)); } frequencies } diff --git a/src/test/compile-fail/borrowck-array-double-move.rs b/src/test/compile-fail/borrowck-array-double-move.rs index c872d0dc4b9c4..79a6dd005a7ac 100644 --- a/src/test/compile-fail/borrowck-array-double-move.rs +++ b/src/test/compile-fail/borrowck-array-double-move.rs @@ -12,7 +12,7 @@ fn f() { let mut a = [box 0i, box 1i]; drop(a[0]); a[1] = box 2i; - drop(a[0]); //~ ERROR use of moved value: `a[..]` + drop(a[0]); //~ ERROR use of moved value: `a.index(&(..))` } fn main() { diff --git a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs index cb8762f44fb79..b328ea722a09a 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs @@ -14,6 +14,6 @@ fn main() { [1, 2, tail..] => tail, _ => unreachable!() }; - a[0] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed + a[0] = 0; //~ ERROR cannot assign to `a.index(&(..))` because it is borrowed t[0]; } diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs index 5c0aba42b9683..0d8631788a9e1 100644 --- a/src/test/compile-fail/packed-struct-generic-transmute.rs +++ b/src/test/compile-fail/packed-struct-generic-transmute.rs @@ -34,6 +34,6 @@ fn main() { let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 }; unsafe { let oof: Oof<[u8; 5], i32> = mem::transmute(foo); - println!("{} {}", oof.rab[], oof.zab); + println!("{} {}", oof.rab.index(&FullRange), oof.zab); } } diff --git a/src/test/compile-fail/slice-1.rs b/src/test/compile-fail/slice-1.rs index d0339745c9eaf..26281c2e90754 100644 --- a/src/test/compile-fail/slice-1.rs +++ b/src/test/compile-fail/slice-1.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test slicing expr[..] is an error and gives a helpful error message. +// Test slicing expr.index(&(..)) is an error and gives a helpful error message. struct Foo; fn main() { let x = Foo; - x[..]; //~ ERROR incorrect slicing expression: `[..]` - //~^ NOTE use `expr[]` to construct a slice of the whole of expr + x.index(&(..)); //~ ERROR incorrect slicing expression: `[..]` + //~^ NOTE use `expr.index(&FullRange)` to construct a slice of the whole of expr } diff --git a/src/test/compile-fail/slice-2.rs b/src/test/compile-fail/slice-2.rs index 24f710d2ae3f4..1e850d6307eb4 100644 --- a/src/test/compile-fail/slice-2.rs +++ b/src/test/compile-fail/slice-2.rs @@ -16,8 +16,8 @@ struct Foo; fn main() { let x = Foo; - x[]; //~ ERROR cannot take a slice of a value with type `Foo` - x[Foo..]; //~ ERROR cannot take a slice of a value with type `Foo` - x[..Foo]; //~ ERROR cannot take a slice of a value with type `Foo` - x[Foo..Foo]; //~ ERROR cannot take a slice of a value with type `Foo` + x.index(&FullRange); //~ ERROR cannot take a slice of a value with type `Foo` + x.index(&(Foo..)); //~ ERROR cannot take a slice of a value with type `Foo` + x.index(&(0..Foo)); //~ ERROR cannot take a slice of a value with type `Foo` + x.index(&(Foo..Foo)); //~ ERROR cannot take a slice of a value with type `Foo` } diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs index 00783b71ea11d..7839013ee2224 100644 --- a/src/test/compile-fail/slice-borrow.rs +++ b/src/test/compile-fail/slice-borrow.rs @@ -16,6 +16,6 @@ fn main() { let y; { let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough - y = x[1..]; + y = x.index(&(1..)); } } diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs index 8970bcfd153a1..b7d7ea67f067c 100644 --- a/src/test/compile-fail/slice-mut-2.rs +++ b/src/test/compile-fail/slice-mut-2.rs @@ -16,5 +16,5 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Can't mutably slice an immutable slice let slice: &mut [int] = &mut [0, 1]; - x[2..4] = slice; //~ ERROR cannot borrow + x.index(&(2..4)) = slice; //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs index ad6b384d74701..3d621580f5d4a 100644 --- a/src/test/compile-fail/slice-mut.rs +++ b/src/test/compile-fail/slice-mut.rs @@ -15,5 +15,5 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Immutable slices are not mutable. - let y: &mut[_] = x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl + let y: &mut[_] = x.index(&(2..4)); //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl } diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs index 70211d74d885d..f2cb5f82a6c4c 100644 --- a/src/test/debuginfo/vec-slices.rs +++ b/src/test/debuginfo/vec-slices.rs @@ -93,7 +93,7 @@ fn main() { let empty: &[i64] = &[]; let singleton: &[i64] = &[1]; let multiple: &[i64] = &[2, 3, 4, 5]; - let slice_of_slice = multiple[1..3]; + let slice_of_slice = multiple.index(&(1..3)); let padded_tuple: &[(i32, i16)] = &[(6, 7), (8, 9)]; diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 24df95ffd3cb6..6eb4bc352d194 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -35,7 +35,7 @@ fn test_rbml<'a, 'b, A: let mut rbml_w = EBwriter::Encoder::new(&mut wr); a1.encode(&mut rbml_w); - let d: serialize::rbml::Doc<'a> = EBDoc::new(wr[]); + let d: serialize::rbml::Doc<'a> = EBDoc::new(wr.index(&FullRange)); let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d); let a2: A = Decodable::decode(&mut decoder); assert!(*a1 == a2); diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index 2466d0adf7bc3..459060d349ce4 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -59,7 +59,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable> + let mut w = Vec::new(); let mut e = Encoder::new(&mut w); obj.encode(&mut e); - let doc = rbml::Doc::new(@w[]); + let doc = rbml::Doc::new(@w.index(&FullRange)); let mut dec = Decoder::new(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/issue-15730.rs b/src/test/run-pass/issue-15730.rs index a1a5922e15003..4e1aa454a881d 100644 --- a/src/test/run-pass/issue-15730.rs +++ b/src/test/run-pass/issue-15730.rs @@ -12,5 +12,5 @@ fn main() { let mut array = [1, 2, 3]; - let pie_slice = array[1..2]; + let pie_slice = &array[1..2]; } diff --git a/src/test/run-pass/issue-17503.rs b/src/test/run-pass/issue-17503.rs index 986879e8e461d..9d1a51ad79c08 100644 --- a/src/test/run-pass/issue-17503.rs +++ b/src/test/run-pass/issue-17503.rs @@ -15,7 +15,7 @@ fn main() { let ss: &&[int] = &s; let sss: &&&[int] = &ss; - println!("{}", s[..3]); - println!("{}", ss[3..]); - println!("{}", sss[2..4]); + println!("{}", s.index(&(0..3))); + println!("{}", ss.index(&(3..))); + println!("{}", sss.index(&(2..4))); } diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs index 10add853ee7f3..115a96d52898d 100644 --- a/src/test/run-pass/issue-3888-2.rs +++ b/src/test/run-pass/issue-3888-2.rs @@ -11,7 +11,7 @@ #![feature(slicing_syntax)] fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] { - v[1..5] + v.index(&(1..5)) } pub fn main() {} diff --git a/src/test/run-pass/issue-4464.rs b/src/test/run-pass/issue-4464.rs index f2c1a715b514b..fa75b5d2583d5 100644 --- a/src/test/run-pass/issue-4464.rs +++ b/src/test/run-pass/issue-4464.rs @@ -10,6 +10,6 @@ #![feature(slicing_syntax)] -fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v[i..j] } +fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v.index(&(i..j)) } pub fn main() {} diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs index 305f984f98efb..706f640c18d95 100644 --- a/src/test/run-pass/issue-8898.rs +++ b/src/test/run-pass/issue-8898.rs @@ -18,11 +18,11 @@ pub fn main() { let abc = [1i, 2, 3]; let tf = [true, false]; let x = [(), ()]; - let slice = x[0..1]; + let slice = x.index(&(0..1)); - assert_repr_eq(abc[], "[1, 2, 3]".to_string()); - assert_repr_eq(tf[], "[true, false]".to_string()); - assert_repr_eq(x[], "[(), ()]".to_string()); + assert_repr_eq(abc.index(&FullRange), "[1, 2, 3]".to_string()); + assert_repr_eq(tf.index(&FullRange), "[true, false]".to_string()); + assert_repr_eq(x.index(&FullRange), "[(), ()]".to_string()); assert_repr_eq(slice, "[()]".to_string()); - assert_repr_eq(x[], "[(), ()]".to_string()); + assert_repr_eq(x.index(&FullRange), "[(), ()]".to_string()); } diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs index 0781822cb7482..e5a617634632f 100644 --- a/src/test/run-pass/repeated-vector-syntax.rs +++ b/src/test/run-pass/repeated-vector-syntax.rs @@ -19,5 +19,5 @@ pub fn main() { print!("{}, ", (*xi)[]); } println!("]"); - println!("{}", y[]); + println!("{}", y.index(&FullRange)); } diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs index f03b4609637a9..7be05b9d71e53 100644 --- a/src/test/run-pass/slice-2.rs +++ b/src/test/run-pass/slice-2.rs @@ -15,23 +15,23 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; let cmp: &[int] = &[1, 2, 3, 4, 5]; - assert!(x[] == cmp); + assert!(x.index(&FullRange) == cmp); let cmp: &[int] = &[3, 4, 5]; - assert!(x[2..] == cmp); + assert!(x.index(&(2..)) == cmp); let cmp: &[int] = &[1, 2, 3]; - assert!(x[..3] == cmp); + assert!(x.index(&(0..3)) == cmp); let cmp: &[int] = &[2, 3, 4]; - assert!(x[1..4] == cmp); + assert!(x.index(&(1..4)) == cmp); let x: Vec = vec![1, 2, 3, 4, 5]; let cmp: &[int] = &[1, 2, 3, 4, 5]; - assert!(x[] == cmp); + assert!(x.index(&FullRange) == cmp); let cmp: &[int] = &[3, 4, 5]; - assert!(x[2..] == cmp); + assert!(x.index(&(2..)) == cmp); let cmp: &[int] = &[1, 2, 3]; - assert!(x[..3] == cmp); + assert!(x.index(&(0..3)) == cmp); let cmp: &[int] = &[2, 3, 4]; - assert!(x[1..4] == cmp); + assert!(x.index(&(1..4)) == cmp); let x: &mut [int] = &mut [1, 2, 3, 4, 5]; { diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs index 13f2971871ba8..87de4246f3e6d 100644 --- a/src/test/run-pass/slice-panic-1.rs +++ b/src/test/run-pass/slice-panic-1.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test that is a slicing expr[..] fails, the correct cleanups happen. +// Test that is a slicing expr.index(&(..)) fails, the correct cleanups happen. #![feature(slicing_syntax)] @@ -24,7 +24,7 @@ impl Drop for Foo { fn foo() { let x: &[_] = &[Foo, Foo]; - x[3..4]; + x.index(&(3..4)); } fn main() { diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs index ccbb33d7768c4..afffaba64ded7 100644 --- a/src/test/run-pass/slice-panic-2.rs +++ b/src/test/run-pass/slice-panic-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test that is a slicing expr[..] fails, the correct cleanups happen. +// Test that is a slicing expr.index(&(..)) fails, the correct cleanups happen. #![feature(slicing_syntax)] diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs index f863c4d330fbf..c6dfc8dfd23a3 100644 --- a/src/test/run-pass/slice.rs +++ b/src/test/run-pass/slice.rs @@ -58,10 +58,10 @@ impl SliceMut for Foo { } fn main() { let mut x = Foo; - x[]; - x[Foo..]; - x[..Foo]; - x[Foo..Foo]; + x.index(&FullRange); + x.index(&(Foo..)); + x.index(&(0..Foo)); + x.index(&(Foo..Foo)); x[mut]; x[mut Foo..]; x[mut ..Foo]; From 5a4ca319185a3f399986bc5e5a2d0a96fac583ae Mon Sep 17 00:00:00 2001 From: Corey Richardson Date: Fri, 5 Dec 2014 18:12:25 -0800 Subject: [PATCH 28/49] test fallout from isize/usize --- src/librustc_resolve/lib.rs | 4 +- src/libsyntax/ast_util.rs | 4 +- src/test/compile-fail/array-not-vector.rs | 6 +- .../compile-fail/associated-types-eq-3.rs | 4 +- ...ted-types-invalid-trait-ref-issue-18865.rs | 4 +- .../compile-fail/associated-types-path-2.rs | 14 ++-- src/test/compile-fail/autoderef-full-lval.rs | 10 +-- src/test/compile-fail/bad-const-type.rs | 4 +- src/test/compile-fail/binop-logic-int.rs | 4 +- src/test/compile-fail/coercion-slice.rs | 2 +- src/test/compile-fail/dst-bad-coerce1.rs | 8 +- src/test/compile-fail/dst-bad-coerce4.rs | 8 +- .../compile-fail/dst-sized-trait-param.rs | 8 +- src/test/compile-fail/fn-trait-formatting.rs | 16 ++-- .../fully-qualified-type-name1.rs | 4 +- .../fully-qualified-type-name4.rs | 4 +- .../generic-type-params-name-repr.rs | 20 ++--- src/test/compile-fail/hrtb-just-for-static.rs | 12 +-- .../compile-fail/hrtb-perfect-forwarding.rs | 24 +++--- src/test/compile-fail/hrtb-type-outlives.rs | 14 ++-- src/test/compile-fail/if-branch-types.rs | 4 +- src/test/compile-fail/issue-10176.rs | 4 +- src/test/compile-fail/issue-10991.rs | 2 +- src/test/compile-fail/issue-12997-2.rs | 4 +- src/test/compile-fail/issue-13058.rs | 10 +-- src/test/compile-fail/issue-13359.rs | 4 +- src/test/compile-fail/issue-13466.rs | 6 +- src/test/compile-fail/issue-14915.rs | 4 +- src/test/compile-fail/issue-16250.rs | 2 +- src/test/compile-fail/issue-17441.rs | 14 ++-- src/test/compile-fail/issue-17444.rs | 4 +- src/test/compile-fail/issue-17651.rs | 4 +- src/test/compile-fail/issue-17905.rs | 8 +- src/test/compile-fail/issue-18611.rs | 4 +- src/test/compile-fail/issue-4517.rs | 8 +- src/test/compile-fail/issue-4968.rs | 4 +- src/test/compile-fail/issue-5239-1.rs | 4 +- src/test/compile-fail/issue-7575.rs | 40 ++++----- src/test/compile-fail/issue-7867.rs | 6 +- src/test/compile-fail/issue-8761.rs | 4 +- src/test/compile-fail/issue-9575.rs | 4 +- src/test/compile-fail/map-types.rs | 8 +- src/test/compile-fail/method-self-arg-1.rs | 2 +- .../compile-fail/mut-pattern-mismatched.rs | 8 +- src/test/compile-fail/noexporttypeexe.rs | 2 +- src/test/compile-fail/pptypedef.rs | 8 +- .../regions-infer-paramd-indirect.rs | 5 +- src/test/compile-fail/repeat_count.rs | 8 +- .../structure-constructor-type-mismatch.rs | 32 +++---- .../trait-bounds-impl-comparison-1.rs | 10 +-- .../trait-coercion-generic-bad.rs | 4 +- src/test/compile-fail/trait-impl-1.rs | 4 +- src/test/compile-fail/tuple-arity-mismatch.rs | 4 +- .../compile-fail/tuple-index-out-of-bounds.rs | 6 +- .../tutorial-suffix-inference-test.rs | 6 +- .../compile-fail/type-mismatch-multiple.rs | 4 +- .../typeck_type_placeholder_mismatch.rs | 10 +-- src/test/compile-fail/variadic-ffi.rs | 16 ++-- .../compile-fail/warn-foreign-int-types.rs | 6 +- .../debuginfo/basic-types-globals-metadata.rs | 4 +- src/test/debuginfo/basic-types-metadata.rs | 8 +- src/test/debuginfo/option-like-enum.rs | 12 +-- src/test/debuginfo/type-names.rs | 82 +++++++++--------- src/test/pretty/issue-4264.pp | 31 +++---- src/test/pretty/issue-4264.rs | 18 ++-- .../graphviz-flowgraph/f01.dot-expected.dot | 6 +- .../graphviz-flowgraph/f03.dot-expected.dot | 8 +- .../graphviz-flowgraph/f04.dot-expected.dot | 6 +- .../graphviz-flowgraph/f05.dot-expected.dot | 10 +-- .../graphviz-flowgraph/f07.dot-expected.dot | 16 ++-- .../graphviz-flowgraph/f08.dot-expected.dot | 20 ++--- .../graphviz-flowgraph/f09.dot-expected.dot | 34 ++++---- src/test/run-make/graphviz-flowgraph/f09.rs | 8 +- .../graphviz-flowgraph/f10.dot-expected.dot | 20 ++--- .../graphviz-flowgraph/f11.dot-expected.dot | 18 ++-- .../graphviz-flowgraph/f12.dot-expected.dot | 24 +++--- .../graphviz-flowgraph/f14.dot-expected.dot | 12 +-- .../graphviz-flowgraph/f15.dot-expected.dot | 58 ++++++------- .../graphviz-flowgraph/f16.dot-expected.dot | 60 ++++++------- .../graphviz-flowgraph/f17.dot-expected.dot | 12 +-- .../graphviz-flowgraph/f20.dot-expected.dot | 18 ++-- .../graphviz-flowgraph/f21.dot-expected.dot | 52 ++++++------ .../graphviz-flowgraph/f22.dot-expected.dot | 54 ++++++------ .../graphviz-flowgraph/f23.dot-expected.dot | 66 +++++++-------- .../graphviz-flowgraph/f24.dot-expected.dot | 84 +++++++++---------- .../graphviz-flowgraph/f25.dot-expected.dot | 84 +++++++++---------- 86 files changed, 644 insertions(+), 642 deletions(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index cc9abecc20fc8..d14105326ba9c 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -834,14 +834,14 @@ impl PrimitiveTypeTable { table.intern("f32", TyFloat(TyF32)); table.intern("f64", TyFloat(TyF64)); table.intern("int", TyInt(TyIs)); - table.intern("isize", TyInt(TyIs)); + table.intern("isize", TyInt(TyIs)); table.intern("i8", TyInt(TyI8)); table.intern("i16", TyInt(TyI16)); table.intern("i32", TyInt(TyI32)); table.intern("i64", TyInt(TyI64)); table.intern("str", TyStr); table.intern("uint", TyUint(TyUs)); - table.intern("usize", TyUint(TyUs)); + table.intern("usize", TyUint(TyUs)); table.intern("u8", TyUint(TyU8)); table.intern("u16", TyUint(TyU16)); table.intern("u32", TyUint(TyU32)); diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index d6df9f46621a7..b21233d71c806 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -141,7 +141,7 @@ pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, - TyIs | TyI32 => 0x80000000u64, // actually ni about TyIm + TyIs | TyI32 => 0x80000000u64, // actually ni about TyIs TyI64 => 0x8000000000000000u64 } } @@ -168,7 +168,7 @@ pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, - TyUs | TyU32 => 0xffffffffu64, // actually ni about TyUm + TyUs | TyU32 => 0xffffffffu64, // actually ni about TyUs TyU64 => 0xffffffffffffffffu64 } } diff --git a/src/test/compile-fail/array-not-vector.rs b/src/test/compile-fail/array-not-vector.rs index 7edb4b8754a1f..6581019fdd520 100644 --- a/src/test/compile-fail/array-not-vector.rs +++ b/src/test/compile-fail/array-not-vector.rs @@ -9,8 +9,8 @@ // except according to those terms. fn main() { - let _x: int = [1i, 2, 3]; //~ ERROR expected int, found array of 3 elements + let _x: isize = [1is, 2, 3]; //~ ERROR expected isize, found array of 3 elements - let x: &[int] = &[1, 2, 3]; - let _y: &int = x; //~ ERROR expected int, found slice + let x: &[isize] = &[1, 2, 3]; + let _y: &isize = x; //~ ERROR expected isize, found slice } diff --git a/src/test/compile-fail/associated-types-eq-3.rs b/src/test/compile-fail/associated-types-eq-3.rs index 0f18a84cd1ae3..b56f971db7449 100644 --- a/src/test/compile-fail/associated-types-eq-3.rs +++ b/src/test/compile-fail/associated-types-eq-3.rs @@ -41,6 +41,6 @@ pub fn baz(x: &Foo) { pub fn main() { let a = 42i; - foo1(a); //~ERROR expected uint, found struct Bar - baz(&a); //~ERROR expected uint, found struct Bar + foo1(a); //~ERROR expected usize, found struct Bar + baz(&a); //~ERROR expected usize, found struct Bar } diff --git a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs index b04b83e575bf4..13f6dcc9fdee4 100644 --- a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs +++ b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs @@ -17,8 +17,8 @@ trait Foo { } fn f>(t: &T) { - let u: >::Bar = t.get_bar(); - //~^ ERROR the trait `Foo` is not implemented for the type `T` + let u: >::Bar = t.get_bar(); + //~^ ERROR the trait `Foo` is not implemented for the type `T` } fn main() { } diff --git a/src/test/compile-fail/associated-types-path-2.rs b/src/test/compile-fail/associated-types-path-2.rs index ef85fc22fe7d4..9994a0c465f79 100644 --- a/src/test/compile-fail/associated-types-path-2.rs +++ b/src/test/compile-fail/associated-types-path-2.rs @@ -24,29 +24,29 @@ pub fn f2(a: T) -> T::A { } pub fn f1_int_int() { - f1(2i, 4i); - //~^ ERROR expected uint, found int + f1(2is, 4is); + //~^ ERROR expected usize, found isize } pub fn f1_int_uint() { - f1(2i, 4u); + f1(2is, 4us); } pub fn f1_uint_uint() { - f1(2u, 4u); + f1(2us, 4us); //~^ ERROR the trait `Foo` is not implemented //~| ERROR the trait `Foo` is not implemented } pub fn f1_uint_int() { - f1(2u, 4i); + f1(2us, 4is); //~^ ERROR the trait `Foo` is not implemented //~| ERROR the trait `Foo` is not implemented } pub fn f2_int() { - let _: int = f2(2i); - //~^ ERROR expected `int`, found `uint` + let _: int = f2(2is); + //~^ ERROR expected `isize`, found `usize` } pub fn main() { } diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index 7aa3b30ce4919..bbe5af1b51675 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -9,24 +9,24 @@ // except according to those terms. struct clam { - x: Box, - y: Box, + x: Box, + y: Box, } struct fish { - a: Box, + a: Box, } fn main() { let a: clam = clam{x: box 1, y: box 2}; let b: clam = clam{x: box 10, y: box 20}; - let z: int = a.x + b.y; //~ ERROR binary operation `+` cannot be applied to type `Box` + let z: isize = a.x + b.y; //~ ERROR binary operation `+` cannot be applied to type `Box` println!("{}", z); assert_eq!(z, 21); let forty: fish = fish{a: box 40}; let two: fish = fish{a: box 2}; let answer: int = forty.a + two.a; - //~^ ERROR binary operation `+` cannot be applied to type `Box` + //~^ ERROR binary operation `+` cannot be applied to type `Box` println!("{}", answer); assert_eq!(answer, 42); } diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs index 13b19141c16cc..2450f22669a51 100644 --- a/src/test/compile-fail/bad-const-type.rs +++ b/src/test/compile-fail/bad-const-type.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:expected `collections::string::String`, found `int` +// error-pattern:expected `collections::string::String`, found `isize` -static i: String = 10i; +static i: String = 10is; fn main() { println!("{}", i); } diff --git a/src/test/compile-fail/binop-logic-int.rs b/src/test/compile-fail/binop-logic-int.rs index 0a53293d67696..0067121e6103a 100644 --- a/src/test/compile-fail/binop-logic-int.rs +++ b/src/test/compile-fail/binop-logic-int.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:`&&` cannot be applied to type `int` +// error-pattern:`&&` cannot be applied to type `isize` -fn main() { let x = 1i && 2i; } +fn main() { let x = 1is && 2is; } diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs index b6b46fadb13da..8d48ede0e1543 100644 --- a/src/test/compile-fail/coercion-slice.rs +++ b/src/test/compile-fail/coercion-slice.rs @@ -11,5 +11,5 @@ // Tests that we forbid coercion from `[T; n]` to `&[T]` fn main() { - let _: &[int] = [0i]; //~ERROR: mismatched types: expected `&[int]`, found `[int; 1]` + let _: &[isize] = [0is]; //~ERROR: mismatched types: expected `&[isize]`, found `[isize; 1]` } diff --git a/src/test/compile-fail/dst-bad-coerce1.rs b/src/test/compile-fail/dst-bad-coerce1.rs index 75bd94331b11d..e70db87a39a41 100644 --- a/src/test/compile-fail/dst-bad-coerce1.rs +++ b/src/test/compile-fail/dst-bad-coerce1.rs @@ -18,11 +18,11 @@ struct Foo; trait Bar {} pub fn main() { - // With a vec of ints. + // With a vec of isize. let f1 = Fat { ptr: [1, 2, 3] }; - let f2: &Fat<[int; 3]> = &f1; - let f3: &Fat<[uint]> = f2; - //~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int; 3]>` + let f2: &Fat<[isize; 3]> = &f1; + let f3: &Fat<[usize]> = f2; + //~^ ERROR mismatched types: expected `&Fat<[usize]>`, found `&Fat<[isize; 3]>` // With a trait. let f1 = Fat { ptr: Foo }; diff --git a/src/test/compile-fail/dst-bad-coerce4.rs b/src/test/compile-fail/dst-bad-coerce4.rs index 53ce18c73a088..8e81eacae921e 100644 --- a/src/test/compile-fail/dst-bad-coerce4.rs +++ b/src/test/compile-fail/dst-bad-coerce4.rs @@ -15,8 +15,8 @@ struct Fat { } pub fn main() { - // With a vec of ints. - let f1: &Fat<[int]> = &Fat { ptr: [1, 2, 3] }; - let f2: &Fat<[int; 3]> = f1; - //~^ ERROR mismatched types: expected `&Fat<[int; 3]>`, found `&Fat<[int]>` + // With a vec of isizes. + let f1: &Fat<[isize]> = &Fat { ptr: [1, 2, 3] }; + let f2: &Fat<[isize; 3]> = f1; + //~^ ERROR mismatched types: expected `&Fat<[isize; 3]>`, found `&Fat<[isize]>` } diff --git a/src/test/compile-fail/dst-sized-trait-param.rs b/src/test/compile-fail/dst-sized-trait-param.rs index ea5becbf229c0..a65ca8b84f893 100644 --- a/src/test/compile-fail/dst-sized-trait-param.rs +++ b/src/test/compile-fail/dst-sized-trait-param.rs @@ -14,10 +14,10 @@ trait Foo : Sized { fn take(self, x: &T) { } } // Note: T is sized -impl Foo<[int]> for uint { } -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[int]` +impl Foo<[isize]> for uint { } +//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[isize]` -impl Foo for [uint] { } -//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[uint]` +impl Foo for [usize] { } +//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[usize]` pub fn main() { } diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs index 3eeb4c177cad6..06e8412ddaa23 100644 --- a/src/test/compile-fail/fn-trait-formatting.rs +++ b/src/test/compile-fail/fn-trait-formatting.rs @@ -10,15 +10,15 @@ #![feature(unboxed_closures)] -fn needs_fn(x: F) where F: Fn(int) -> int {} +fn needs_fn(x: F) where F: Fn(isize) -> isize {} fn main() { - let _: () = (box |:_: int| {}) as Box; //~ ERROR object-safe - //~^ ERROR Box - let _: () = (box |&:_: int, int| {}) as Box; - //~^ ERROR Box - let _: () = (box |&mut:| -> int unimplemented!()) as Box int>; - //~^ ERROR Box int> + let _: () = (box |:_: isize| {}) as Box; //~ ERROR object-safe + //~^ ERROR Box + let _: () = (box |&:_: isize, isize| {}) as Box; + //~^ ERROR Box + let _: () = (box |&mut:| -> isize unimplemented!()) as Box isize>; + //~^ ERROR Box isize> - needs_fn(1i); //~ ERROR `core::ops::Fn(int) -> int` + needs_fn(1i); //~ ERROR `core::ops::Fn(isize) -> isize` } diff --git a/src/test/compile-fail/fully-qualified-type-name1.rs b/src/test/compile-fail/fully-qualified-type-name1.rs index c5e7fc82cc994..5ab946a53e5cc 100644 --- a/src/test/compile-fail/fully-qualified-type-name1.rs +++ b/src/test/compile-fail/fully-qualified-type-name1.rs @@ -11,7 +11,7 @@ // Test that we use fully-qualified type names in error messages. fn main() { - let x: Option; + let x: Option; x = 5; - //~^ ERROR mismatched types: expected `core::option::Option` + //~^ ERROR mismatched types: expected `core::option::Option` } diff --git a/src/test/compile-fail/fully-qualified-type-name4.rs b/src/test/compile-fail/fully-qualified-type-name4.rs index 768ae6353d225..9250444c3e6cd 100644 --- a/src/test/compile-fail/fully-qualified-type-name4.rs +++ b/src/test/compile-fail/fully-qualified-type-name4.rs @@ -12,9 +12,9 @@ use std::option::Option; -fn bar(x: uint) -> Option { +fn bar(x: usize) -> Option { return x; - //~^ ERROR mismatched types: expected `core::option::Option` + //~^ ERROR mismatched types: expected `core::option::Option` } fn main() { diff --git a/src/test/compile-fail/generic-type-params-name-repr.rs b/src/test/compile-fail/generic-type-params-name-repr.rs index 5bdee543d738d..5769b9d7932c0 100644 --- a/src/test/compile-fail/generic-type-params-name-repr.rs +++ b/src/test/compile-fail/generic-type-params-name-repr.rs @@ -18,22 +18,22 @@ struct HashMap>; fn main() { // Ensure that the printed type doesn't include the default type params... - let _: Foo = (); - //~^ ERROR mismatched types: expected `Foo`, found `()` + let _: Foo = (); + //~^ ERROR mismatched types: expected `Foo`, found `()` // ...even when they're present, but the same types as the defaults. - let _: Foo = (); - //~^ ERROR mismatched types: expected `Foo`, found `()` + let _: Foo = (); + //~^ ERROR mismatched types: expected `Foo`, found `()` // Including cases where the default is using previous type params. - let _: HashMap = (); - //~^ ERROR mismatched types: expected `HashMap`, found `()` - let _: HashMap> = (); - //~^ ERROR mismatched types: expected `HashMap`, found `()` + let _: HashMap = (); + //~^ ERROR mismatched types: expected `HashMap`, found `()` + let _: HashMap> = (); + //~^ ERROR mismatched types: expected `HashMap`, found `()` // But not when there's a different type in between. - let _: Foo = (); - //~^ ERROR mismatched types: expected `Foo`, found `()` + let _: Foo = (); + //~^ ERROR mismatched types: expected `Foo`, found `()` // And don't print <> at all when there's just defaults. let _: Foo = (); diff --git a/src/test/compile-fail/hrtb-just-for-static.rs b/src/test/compile-fail/hrtb-just-for-static.rs index 36a45400eec1a..a1ec4a739e8ce 100644 --- a/src/test/compile-fail/hrtb-just-for-static.rs +++ b/src/test/compile-fail/hrtb-just-for-static.rs @@ -16,22 +16,22 @@ trait Foo { } fn want_hrtb() - where T : for<'a> Foo<&'a int> + where T : for<'a> Foo<&'a isize> { } -// AnyInt implements Foo<&'a int> for any 'a, so it is a match. +// AnyInt implements Foo<&'a isize> for any 'a, so it is a match. struct AnyInt; -impl<'a> Foo<&'a int> for AnyInt { } +impl<'a> Foo<&'a isize> for AnyInt { } fn give_any() { want_hrtb::() } -// StaticInt only implements Foo<&'static int>, so it is an error. +// StaticInt only implements Foo<&'static isize>, so it is an error. struct StaticInt; -impl Foo<&'static int> for StaticInt { } +impl Foo<&'static isize> for StaticInt { } fn give_static() { - want_hrtb::() //~ ERROR `for<'a> Foo<&'a int>` is not implemented + want_hrtb::() //~ ERROR `for<'a> Foo<&'a isize>` is not implemented } fn main() { } diff --git a/src/test/compile-fail/hrtb-perfect-forwarding.rs b/src/test/compile-fail/hrtb-perfect-forwarding.rs index a8ee2154fc396..e8ecc0608fc4a 100644 --- a/src/test/compile-fail/hrtb-perfect-forwarding.rs +++ b/src/test/compile-fail/hrtb-perfect-forwarding.rs @@ -30,36 +30,36 @@ impl<'a,X,F> Bar for &'a mut F } fn no_hrtb<'b,T>(mut t: T) - where T : Bar<&'b int> + where T : Bar<&'b isize> { - // OK -- `T : Bar<&'b int>`, and thus the impl above ensures that - // `&mut T : Bar<&'b int>`. + // OK -- `T : Bar<&'b isize>`, and thus the impl above ensures that + // `&mut T : Bar<&'b isize>`. no_hrtb(&mut t); } fn bar_hrtb(mut t: T) - where T : for<'b> Bar<&'b int> + where T : for<'b> Bar<&'b isize> { - // OK -- `T : for<'b> Bar<&'b int>`, and thus the impl above - // ensures that `&mut T : for<'b> Bar<&'b int>`. This is an + // OK -- `T : for<'b> Bar<&'b isize>`, and thus the impl above + // ensures that `&mut T : for<'b> Bar<&'b isize>`. This is an // example of a "perfect forwarding" impl. bar_hrtb(&mut t); } fn foo_hrtb_bar_not<'b,T>(mut t: T) - where T : for<'a> Foo<&'a int> + Bar<&'b int> + where T : for<'a> Foo<&'a isize> + Bar<&'b isize> { // Not OK -- The forwarding impl for `Foo` requires that `Bar` also // be implemented. Thus to satisfy `&mut T : for<'a> Foo<&'a - // int>`, we require `T : for<'a> Bar<&'a int>`, but the where - // clause only specifies `T : Bar<&'b int>`. - foo_hrtb_bar_not(&mut t); //~ ERROR `for<'a> Bar<&'a int>` is not implemented for the type `T` + // isize>`, we require `T : for<'a> Bar<&'a isize>`, but the where + // clause only specifies `T : Bar<&'b isize>`. + foo_hrtb_bar_not(&mut t); //~ ERROR `for<'a> Bar<&'a isize>` is not implemented for the type `T` } fn foo_hrtb_bar_hrtb(mut t: T) - where T : for<'a> Foo<&'a int> + for<'b> Bar<&'b int> + where T : for<'a> Foo<&'a isize> + for<'b> Bar<&'b isize> { - // OK -- now we have `T : for<'b> Bar&'b int>`. + // OK -- now we have `T : for<'b> Bar&'b isize>`. foo_hrtb_bar_hrtb(&mut t); } diff --git a/src/test/compile-fail/hrtb-type-outlives.rs b/src/test/compile-fail/hrtb-type-outlives.rs index 9fe8f9ab46ddc..7bb74d6b03a33 100644 --- a/src/test/compile-fail/hrtb-type-outlives.rs +++ b/src/test/compile-fail/hrtb-type-outlives.rs @@ -17,7 +17,7 @@ trait Foo { } fn want_foo() - where T : for<'a> Foo<&'a int> + where T : for<'a> Foo<&'a isize> { } @@ -28,7 +28,7 @@ struct SomeStruct { x: X } -impl<'a,X> Foo<&'a int> for SomeStruct +impl<'a,X> Foo<&'a isize> for SomeStruct where X : 'a { } @@ -36,8 +36,8 @@ impl<'a,X> Foo<&'a int> for SomeStruct fn one() { // In fact there is no good reason for this to be an error, but // whatever, I'm mostly concerned it doesn't ICE right now: - want_foo::>(); - //~^ ERROR requirement `for<'a> uint : 'a` is not satisfied + want_foo::>(); + //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied } /////////////////////////////////////////////////////////////////////////// @@ -47,13 +47,13 @@ struct AnotherStruct { x: X } -impl<'a,X:'a> Foo<&'a int> for AnotherStruct +impl<'a,X:'a> Foo<&'a isize> for AnotherStruct { } fn two() { - want_foo::>(); - //~^ ERROR requirement `for<'a> uint : 'a` is not satisfied + want_foo::>(); + //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied } fn main() { } diff --git a/src/test/compile-fail/if-branch-types.rs b/src/test/compile-fail/if-branch-types.rs index 4a8c72c3877c5..be54554a3c02f 100644 --- a/src/test/compile-fail/if-branch-types.rs +++ b/src/test/compile-fail/if-branch-types.rs @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - let x = if true { 10i } else { 10u }; - //~^ ERROR if and else have incompatible types: expected `int`, found `uint` + let x = if true { 10is } else { 10us }; + //~^ ERROR if and else have incompatible types: expected `isize`, found `usize` } diff --git a/src/test/compile-fail/issue-10176.rs b/src/test/compile-fail/issue-10176.rs index f537d5cad9779..832cc57bd24df 100644 --- a/src/test/compile-fail/issue-10176.rs +++ b/src/test/compile-fail/issue-10176.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f() -> int { +fn f() -> isize { (return 1, return 2) -//~^ ERROR mismatched types: expected `int`, found `(_, _)` (expected int, found tuple) +//~^ ERROR mismatched types: expected `isize`, found `(_, _)` (expected isize, found tuple) } fn main() {} diff --git a/src/test/compile-fail/issue-10991.rs b/src/test/compile-fail/issue-10991.rs index 8f7e6470f9095..2913ddf395fbb 100644 --- a/src/test/compile-fail/issue-10991.rs +++ b/src/test/compile-fail/issue-10991.rs @@ -10,5 +10,5 @@ fn main() { let nil = (); - let _t = nil as uint; //~ ERROR: cast from nil: `()` as `uint` + let _t = nil as usize; //~ ERROR: cast from nil: `()` as `usize` } diff --git a/src/test/compile-fail/issue-12997-2.rs b/src/test/compile-fail/issue-12997-2.rs index 83f6fb072329d..39957a242268f 100644 --- a/src/test/compile-fail/issue-12997-2.rs +++ b/src/test/compile-fail/issue-12997-2.rs @@ -12,6 +12,6 @@ //! Test that makes sure wrongly-typed bench functions are rejected -// error-pattern:expected &-ptr, found int +// error-pattern:expected &-ptr, found isize #[bench] -fn bar(x: int) { } +fn bar(x: isize) { } diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs index 8dda54efc06af..8f50786405283 100644 --- a/src/test/compile-fail/issue-13058.rs +++ b/src/test/compile-fail/issue-13058.rs @@ -12,15 +12,15 @@ use std::iter::{Range,range}; trait Itble<'r, T, I: Iterator> { fn iter(&'r self) -> I; } -impl<'r> Itble<'r, uint, Range> for (uint, uint) { - fn iter(&'r self) -> Range { +impl<'r> Itble<'r, usize, Range> for (usize, usize) { + fn iter(&'r self) -> Range { let &(min, max) = self; range(min, max) } } -fn check<'r, I: Iterator, T: Itble<'r, uint, I>>(cont: &T) -> bool -//~^ HELP as shown: fn check<'r, I: Iterator, T: Itble<'r, uint, I>>(cont: &'r T) +fn check<'r, I: Iterator, T: Itble<'r, usize, I>>(cont: &T) -> bool +//~^ HELP as shown: fn check<'r, I: Iterator, T: Itble<'r, usize, I>>(cont: &'r T) { let cont_iter = cont.iter(); //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements @@ -35,5 +35,5 @@ fn check<'r, I: Iterator, T: Itble<'r, uint, I>>(cont: &T) -> bool fn main() { check((3u, 5u)); -//~^ ERROR mismatched types: expected `&_`, found `(uint, uint)` (expected &-ptr, found tuple) +//~^ ERROR mismatched types: expected `&_`, found `(usize, usize)` (expected &-ptr, found tuple) } diff --git a/src/test/compile-fail/issue-13359.rs b/src/test/compile-fail/issue-13359.rs index 5c72c7388a9ee..25e64e070f40b 100644 --- a/src/test/compile-fail/issue-13359.rs +++ b/src/test/compile-fail/issue-13359.rs @@ -14,8 +14,8 @@ fn bar(_s: u32) { } fn main() { foo(1*(1 as int)); - //~^ ERROR: mismatched types: expected `i16`, found `int` (expected i16, found int) + //~^ ERROR: mismatched types: expected `i16`, found `isize` (expected i16, found isize) bar(1*(1 as uint)); - //~^ ERROR: mismatched types: expected `u32`, found `uint` (expected u32, found uint) + //~^ ERROR: mismatched types: expected `u32`, found `usize` (expected u32, found usize) } diff --git a/src/test/compile-fail/issue-13466.rs b/src/test/compile-fail/issue-13466.rs index e150c1a0f2fc8..7d554545b5ed2 100644 --- a/src/test/compile-fail/issue-13466.rs +++ b/src/test/compile-fail/issue-13466.rs @@ -14,8 +14,8 @@ pub fn main() { // The expected arm type `Option` has one type parameter, while // the actual arm `Result` has two. typeck should not be // tricked into looking up a non-existing second type parameter. - let _x: uint = match Some(1u) { - Ok(u) => u, //~ ERROR mismatched types: expected `core::option::Option` - Err(e) => panic!(e) //~ ERROR mismatched types: expected `core::option::Option` + let _x: usize = match Some(1us) { + Ok(u) => u, //~ ERROR mismatched types: expected `core::option::Option` + Err(e) => panic!(e) //~ ERROR mismatched types: expected `core::option::Option` }; } diff --git a/src/test/compile-fail/issue-14915.rs b/src/test/compile-fail/issue-14915.rs index 8cbbfb7b83a55..142fecc31fec1 100644 --- a/src/test/compile-fail/issue-14915.rs +++ b/src/test/compile-fail/issue-14915.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let x: Box = box 0; + let x: Box = box 0; - println!("{}", x + 1); //~ ERROR binary operation `+` cannot be applied to type `Box` + println!("{}", x + 1); //~ ERROR binary operation `+` cannot be applied to type `Box` } diff --git a/src/test/compile-fail/issue-16250.rs b/src/test/compile-fail/issue-16250.rs index 883e79d75e096..c886c97a63607 100644 --- a/src/test/compile-fail/issue-16250.rs +++ b/src/test/compile-fail/issue-16250.rs @@ -11,7 +11,7 @@ #![deny(warnings)] extern { - pub fn foo(x: (int)); //~ ERROR found rust type `int` in foreign module + pub fn foo(x: (isize)); //~ ERROR found rust type `isize` in foreign module } fn main() { diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs index e5da5c5504ef3..6ae4fbca8b04c 100644 --- a/src/test/compile-fail/issue-17441.rs +++ b/src/test/compile-fail/issue-17441.rs @@ -9,16 +9,16 @@ // except according to those terms. fn main() { - let _foo = &[1u, 2] as [uint]; - //~^ ERROR cast to unsized type: `&[uint; 2]` as `[uint]` - //~^^ HELP consider using an implicit coercion to `&[uint]` instead + let _foo = &[1u, 2] as [usize]; + //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]` + //~^^ HELP consider using an implicit coercion to `&[usize]` instead let _bar = box 1u as std::fmt::Show; - //~^ ERROR cast to unsized type: `Box` as `core::fmt::Show` + //~^ ERROR cast to unsized type: `Box` as `core::fmt::Show` //~^^ HELP did you mean `Box`? let _baz = 1u as std::fmt::Show; - //~^ ERROR cast to unsized type: `uint` as `core::fmt::Show` + //~^ ERROR cast to unsized type: `usize` as `core::fmt::Show` //~^^ HELP consider using a box or reference as appropriate - let _quux = [1u, 2] as [uint]; - //~^ ERROR cast to unsized type: `[uint; 2]` as `[uint]` + let _quux = [1u, 2] as [usize]; + //~^ ERROR cast to unsized type: `[usize; 2]` as `[usize]` //~^^ HELP consider using a box or reference as appropriate } diff --git a/src/test/compile-fail/issue-17444.rs b/src/test/compile-fail/issue-17444.rs index 55570e93a9721..011a9c1777638 100644 --- a/src/test/compile-fail/issue-17444.rs +++ b/src/test/compile-fail/issue-17444.rs @@ -13,6 +13,6 @@ enum Test { } fn main() { - let _x = Test::Foo as *const int; - //~^ ERROR illegal cast; cast through an integer first: `Test` as `*const int` + let _x = Test::Foo as *const isize; + //~^ ERROR illegal cast; cast through an integer first: `Test` as `*const isize` } diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs index 970b14c7eb7cc..589f1cf44bf16 100644 --- a/src/test/compile-fail/issue-17651.rs +++ b/src/test/compile-fail/issue-17651.rs @@ -12,7 +12,7 @@ // and rejected. fn main() { - (|&:| box *[0u].as_slice())(); + (|&:| box *[0us].as_slice())(); //~^ ERROR cannot move out of dereference - //~^^ ERROR cannot move a value of type [uint] + //~^^ ERROR cannot move a value of type [usize] } diff --git a/src/test/compile-fail/issue-17905.rs b/src/test/compile-fail/issue-17905.rs index 2b5c0b7de2f9b..1418cdf403993 100644 --- a/src/test/compile-fail/issue-17905.rs +++ b/src/test/compile-fail/issue-17905.rs @@ -13,15 +13,15 @@ struct Pair (T, V); impl Pair< &str, //~ ERROR missing lifetime specifier - int + isize > { - fn say(self: &Pair<&str, int>) { -//~^ ERROR mismatched types: expected `Pair<&'static str, int>`, found `Pair<&str, int>` + fn say(self: &Pair<&str, isize>) { +//~^ ERROR mismatched types: expected `Pair<&'static str, isize>`, found `Pair<&str, isize>` println!("{}", self); } } fn main() { - let result = &Pair("shane", 1i); + let result = &Pair("shane", 1is); result.say(); } diff --git a/src/test/compile-fail/issue-18611.rs b/src/test/compile-fail/issue-18611.rs index 95782630efc82..a662e9ca98ee8 100644 --- a/src/test/compile-fail/issue-18611.rs +++ b/src/test/compile-fail/issue-18611.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn add_state(op: ::State) { -//~^ ERROR the trait `HasState` is not implemented for the type `int` +fn add_state(op: ::State) { +//~^ ERROR the trait `HasState` is not implemented for the type `isize` } trait HasState { diff --git a/src/test/compile-fail/issue-4517.rs b/src/test/compile-fail/issue-4517.rs index 1c5fd9be1bd4d..1943f1e5a1954 100644 --- a/src/test/compile-fail/issue-4517.rs +++ b/src/test/compile-fail/issue-4517.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn bar(int_param: int) {} +fn bar(int_param: usize) {} fn main() { - let foo: [u8; 4] = [1u8; 4u]; + let foo: [u8; 4] = [1u8; 4us]; bar(foo); - //~^ ERROR mismatched types: expected `int`, found `[u8; 4]` - // (expected int, found vector) + //~^ ERROR mismatched types: expected `usize`, found `[u8; 4]` + // (expected usize, found vector) } diff --git a/src/test/compile-fail/issue-4968.rs b/src/test/compile-fail/issue-4968.rs index cf1f1f5908954..88933c0add929 100644 --- a/src/test/compile-fail/issue-4968.rs +++ b/src/test/compile-fail/issue-4968.rs @@ -10,9 +10,9 @@ // Regression test for issue #4968 -const A: (int,int) = (4,2); +const A: (isize,isize) = (4,2); fn main() { match 42 { A => () } - //~^ ERROR mismatched types: expected `_`, found `(int, int)` + //~^ ERROR mismatched types: expected `_`, found `(isize, isize)` // (expected integral variable, found tuple) } diff --git a/src/test/compile-fail/issue-5239-1.rs b/src/test/compile-fail/issue-5239-1.rs index 1691688fd8464..0eaa40efca22b 100644 --- a/src/test/compile-fail/issue-5239-1.rs +++ b/src/test/compile-fail/issue-5239-1.rs @@ -11,6 +11,6 @@ // Regression test for issue #5239 fn main() { - let x = |&: ref x: int| -> int { x += 1; }; - //~^ ERROR binary assignment operation `+=` cannot be applied to type `&int` + let x = |&: ref x: isize| -> isize { x += 1; }; + //~^ ERROR binary assignment operation `+=` cannot be applied to type `&isize` } diff --git a/src/test/compile-fail/issue-7575.rs b/src/test/compile-fail/issue-7575.rs index d5a1040d4b4d9..0d5156956e566 100644 --- a/src/test/compile-fail/issue-7575.rs +++ b/src/test/compile-fail/issue-7575.rs @@ -11,43 +11,43 @@ // Test the mechanism for warning about possible missing `self` declarations. trait CtxtFn { - fn f8(self, uint) -> uint; - fn f9(uint) -> uint; //~ NOTE candidate + fn f8(self, usize) -> usize; + fn f9(usize) -> usize; //~ NOTE candidate } trait OtherTrait { - fn f9(uint) -> uint; //~ NOTE candidate + fn f9(usize) -> usize; //~ NOTE candidate } // Note: this trait is not implemented, but we can't really tell // whether or not an impl would match anyhow without a self -// declaration to match against, so we wind up printing it as a +// declaration to match against, so we wind up prisizeing it as a // candidate. This seems not unreasonable -- perhaps the user meant to // implement it, after all. trait UnusedTrait { - fn f9(uint) -> uint; //~ NOTE candidate + fn f9(usize) -> usize; //~ NOTE candidate } -impl CtxtFn for uint { - fn f8(self, i: uint) -> uint { +impl CtxtFn for usize { + fn f8(self, i: usize) -> usize { i * 4u } - fn f9(i: uint) -> uint { + fn f9(i: usize) -> usize { i * 4u } } -impl OtherTrait for uint { - fn f9(i: uint) -> uint { +impl OtherTrait for usize { + fn f9(i: usize) -> usize { i * 8u } } -struct MyInt(int); +struct Myisize(isize); -impl MyInt { - fn fff(i: int) -> int { //~ NOTE candidate +impl Myisize { + fn fff(i: isize) -> isize { //~ NOTE candidate i } } @@ -64,17 +64,17 @@ impl ManyImplTrait for String { } } -impl ManyImplTrait for uint {} -impl ManyImplTrait for int {} +impl ManyImplTrait for usize {} +impl ManyImplTrait for isize {} impl ManyImplTrait for char {} -impl ManyImplTrait for MyInt {} +impl ManyImplTrait for Myisize {} -fn no_param_bound(u: uint, m: MyInt) -> uint { +fn no_param_bound(u: usize, m: Myisize) -> usize { u.f8(42) + u.f9(342) + m.fff(42) - //~^ ERROR type `uint` does not implement any method in scope named `f9` + //~^ ERROR type `usize` does not implement any method in scope named `f9` //~^^ NOTE found defined static methods, maybe a `self` is missing? - //~^^^ ERROR type `MyInt` does not implement any method in scope named `fff` - //~^^^^ NOTE found defined static methods, maybe a `self` is missing? + //~^^^ ERROR type `Myisize` does not implement any method in scope named `fff` + //~^^^^ NOTE found defined static methods, maybe a `self` is missing? } fn param_bound(t: T) -> bool { diff --git a/src/test/compile-fail/issue-7867.rs b/src/test/compile-fail/issue-7867.rs index f11d5972ee191..e459a243cc8a5 100644 --- a/src/test/compile-fail/issue-7867.rs +++ b/src/test/compile-fail/issue-7867.rs @@ -18,10 +18,10 @@ fn main() { _ => () } - match &Some(42i) { - Some(x) => (), //~ ERROR expected `&core::option::Option`, + match &Some(42is) { + Some(x) => (), //~ ERROR expected `&core::option::Option`, // found `core::option::Option<_>` - None => () //~ ERROR expected `&core::option::Option`, + None => () //~ ERROR expected `&core::option::Option`, // found `core::option::Option<_>` } } diff --git a/src/test/compile-fail/issue-8761.rs b/src/test/compile-fail/issue-8761.rs index 27369f77e883b..3f9e92afba2b1 100644 --- a/src/test/compile-fail/issue-8761.rs +++ b/src/test/compile-fail/issue-8761.rs @@ -10,9 +10,9 @@ enum Foo { A = 1i64, - //~^ ERROR mismatched types: expected `int`, found `i64` + //~^ ERROR mismatched types: expected `isize`, found `i64` B = 2u8 - //~^ ERROR mismatched types: expected `int`, found `u8` + //~^ ERROR mismatched types: expected `isize`, found `u8` } fn main() {} diff --git a/src/test/compile-fail/issue-9575.rs b/src/test/compile-fail/issue-9575.rs index 6e8f7ffb68da4..b7537f2a93251 100644 --- a/src/test/compile-fail/issue-9575.rs +++ b/src/test/compile-fail/issue-9575.rs @@ -9,7 +9,7 @@ // except according to those terms. #[start] -fn start(argc: int, argv: *const *const u8, crate_map: *const u8) -> int { +fn start(argc: isize, argv: *const *const u8, crate_map: *const u8) -> isize { //~^ ERROR incorrect number of function parameters - 0 + 0 } diff --git a/src/test/compile-fail/map-types.rs b/src/test/compile-fail/map-types.rs index b1116a4cca62b..7aafeced3a6f4 100644 --- a/src/test/compile-fail/map-types.rs +++ b/src/test/compile-fail/map-types.rs @@ -19,8 +19,8 @@ impl Map for HashMap {} // Test that trait types printed in error msgs include the type arguments. fn main() { - let x: Box> = box HashMap::new(); - let x: Box> = x; - let y: Box> = box x; - //~^ ERROR the trait `Map` is not implemented + let x: Box> = box HashMap::new(); + let x: Box> = x; + let y: Box> = box x; + //~^ ERROR the trait `Map` is not implemented } diff --git a/src/test/compile-fail/method-self-arg-1.rs b/src/test/compile-fail/method-self-arg-1.rs index 82d75b45394e3..178b73199766e 100644 --- a/src/test/compile-fail/method-self-arg-1.rs +++ b/src/test/compile-fail/method-self-arg-1.rs @@ -20,5 +20,5 @@ fn main() { let x = Foo; Foo::bar(x); //~ERROR mismatched types: expected `&Foo`, found `Foo` Foo::bar(&&x); //~ERROR mismatched types: expected `&Foo`, found `&&Foo` - Foo::bar(&42i); //~ERROR mismatched types: expected `&Foo`, found `&int` + Foo::bar(&42is); //~ERROR mismatched types: expected `&Foo`, found `&isize` } diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs index 81985a3d6aa5b..6a574f07e9d94 100644 --- a/src/test/compile-fail/mut-pattern-mismatched.rs +++ b/src/test/compile-fail/mut-pattern-mismatched.rs @@ -9,18 +9,18 @@ // except according to those terms. fn main() { - let foo = &mut 1i; + let foo = &mut 1is; // (separate lines to ensure the spans are accurate) // SNAP b2085d9 uncomment this after the next snapshot // NOTE(stage0) just in case tidy doesn't check snap's in tests - // let &_ // ~ ERROR expected `&mut int`, found `&_` + // let &_ // ~ ERROR expected `&mut isize`, found `&_` // = foo; let &mut _ = foo; - let bar = &1i; + let bar = &1is; let &_ = bar; - let &mut _ //~ ERROR expected `&int`, found `&mut _` + let &mut _ //~ ERROR expected `&isize`, found `&mut _` = bar; } diff --git a/src/test/compile-fail/noexporttypeexe.rs b/src/test/compile-fail/noexporttypeexe.rs index 7e113d4a8c4cd..4081792b6544a 100644 --- a/src/test/compile-fail/noexporttypeexe.rs +++ b/src/test/compile-fail/noexporttypeexe.rs @@ -18,5 +18,5 @@ fn main() { // because the def_id associated with the type was // not convertible to a path. let x: int = noexporttypelib::foo(); - //~^ ERROR expected `int`, found `core::option::Option` + //~^ ERROR expected `isize`, found `core::option::Option` } diff --git a/src/test/compile-fail/pptypedef.rs b/src/test/compile-fail/pptypedef.rs index ebda4e9103d60..b33b89be35d82 100644 --- a/src/test/compile-fail/pptypedef.rs +++ b/src/test/compile-fail/pptypedef.rs @@ -11,9 +11,9 @@ fn let_in(x: T, f: F) where F: FnOnce(T) {} fn main() { - let_in(3u, |i| { assert!(i == 3i); }); - //~^ ERROR expected `uint`, found `int` + let_in(3u, |i| { assert!(i == 3is); }); + //~^ ERROR expected `usize`, found `isize` - let_in(3i, |i| { assert!(i == 3u); }); - //~^ ERROR expected `int`, found `uint` + let_in(3i, |i| { assert!(i == 3us); }); + //~^ ERROR expected `isize`, found `usize` } diff --git a/src/test/compile-fail/regions-infer-paramd-indirect.rs b/src/test/compile-fail/regions-infer-paramd-indirect.rs index f93907f5e5cb0..0d441380e8144 100644 --- a/src/test/compile-fail/regions-infer-paramd-indirect.rs +++ b/src/test/compile-fail/regions-infer-paramd-indirect.rs @@ -12,7 +12,7 @@ // Check that we correctly infer that b and c must be region // parameterized because they reference a which requires a region. -type a<'a> = &'a int; +type a<'a> = &'a isize; type b<'a> = Box>; struct c<'a> { @@ -30,7 +30,8 @@ impl<'a> set_f<'a> for c<'a> { } fn set_f_bad(&mut self, b: Box) { - self.f = b; //~ ERROR mismatched types: expected `Box>`, found `Box>` + self.f = b; + //~^ ERROR mismatched types: expected `Box>`, found `Box>` } } diff --git a/src/test/compile-fail/repeat_count.rs b/src/test/compile-fail/repeat_count.rs index 3b0ef0c293af7..f851a8244f61e 100644 --- a/src/test/compile-fail/repeat_count.rs +++ b/src/test/compile-fail/repeat_count.rs @@ -15,13 +15,13 @@ fn main() { let a = [0; n]; //~ ERROR expected constant integer for repeat count, found variable let b = [0; ()]; //~^ ERROR expected constant integer for repeat count, found non-constant expression -//~^^ ERROR: expected `uint`, found `()` +//~^^ ERROR: expected `usize`, found `()` let c = [0; true]; //~ ERROR expected positive integer for repeat count, found boolean - //~^ ERROR: expected `uint`, found `bool` + //~^ ERROR: expected `usize`, found `bool` let d = [0; 0.5]; //~ ERROR expected positive integer for repeat count, found float - //~^ ERROR: expected `uint`, found `_` + //~^ ERROR: expected `usize`, found `_` let e = [0; "foo"]; //~ ERROR expected positive integer for repeat count, found string - //~^ ERROR: expected `uint`, found `&'static str` + //~^ ERROR: expected `usize`, found `&'static str` let f = [0; -4]; //~^ ERROR expected positive integer for repeat count, found negative integer let f = [0u; -1]; diff --git a/src/test/compile-fail/structure-constructor-type-mismatch.rs b/src/test/compile-fail/structure-constructor-type-mismatch.rs index a0a481401bd21..fb84c1e2ebe9a 100644 --- a/src/test/compile-fail/structure-constructor-type-mismatch.rs +++ b/src/test/compile-fail/structure-constructor-type-mismatch.rs @@ -24,33 +24,33 @@ type PairF = Pair; fn main() { let pt = PointF { - //~^ ERROR expected f32, found int - x: 1i, - y: 2i, + //~^ ERROR expected f32, found isize + x: 1is, + y: 2is, }; let pt2 = Point:: { - //~^ ERROR expected f32, found int - x: 3i, - y: 4i, + //~^ ERROR expected f32, found isize + x: 3is, + y: 4is, }; let pair = PairF { - //~^ ERROR expected f32, found int - x: 5i, - y: 6i, + //~^ ERROR expected f32, found isize + x: 5is, + y: 6is, }; - let pair2 = PairF:: { - //~^ ERROR expected f32, found int - x: 7i, - y: 8i, + let pair2 = PairF:: { + //~^ ERROR expected f32, found isize + x: 7is, + y: 8is, }; - let pt3 = PointF:: { + let pt3 = PointF:: { //~^ ERROR wrong number of type arguments - x: 9i, - y: 10i, + x: 9is, + y: 10is, }; } diff --git a/src/test/compile-fail/trait-bounds-impl-comparison-1.rs b/src/test/compile-fail/trait-bounds-impl-comparison-1.rs index eec116855c986..5fc80d5660d04 100644 --- a/src/test/compile-fail/trait-bounds-impl-comparison-1.rs +++ b/src/test/compile-fail/trait-bounds-impl-comparison-1.rs @@ -29,7 +29,7 @@ trait Foo { fn test_error8_fn(&self); } -impl Foo for int { +impl Foo for isize { // invalid bound for T, was defined as Eq in trait fn test_error1_fn(&self) {} //~^ ERROR in method `test_error1_fn`, type parameter 0 requires bound `core::cmp::Ord` @@ -66,12 +66,12 @@ impl Foo for int { trait Getter { } trait Trait { - fn method>(); + fn method>(); } -impl Trait for uint { - fn method>() {} - //~^ ERROR in method `method`, type parameter 0 requires bound `Getter` +impl Trait for usize { + fn method>() {} + //~^ ERROR in method `method`, type parameter 0 requires bound `Getter` } fn main() {} diff --git a/src/test/compile-fail/trait-coercion-generic-bad.rs b/src/test/compile-fail/trait-coercion-generic-bad.rs index fcfd079997734..e6ea8e10b22cc 100644 --- a/src/test/compile-fail/trait-coercion-generic-bad.rs +++ b/src/test/compile-fail/trait-coercion-generic-bad.rs @@ -24,7 +24,7 @@ impl Trait<&'static str> for Struct { } fn main() { - let s: Box> = box Struct { person: "Fred" }; - //~^ ERROR the trait `Trait` is not implemented for the type `Struct` + let s: Box> = box Struct { person: "Fred" }; + //~^ ERROR the trait `Trait` is not implemented for the type `Struct` s.f(1); } diff --git a/src/test/compile-fail/trait-impl-1.rs b/src/test/compile-fail/trait-impl-1.rs index 5e2ebc3e620d6..44b478bfb152b 100644 --- a/src/test/compile-fail/trait-impl-1.rs +++ b/src/test/compile-fail/trait-impl-1.rs @@ -21,6 +21,6 @@ impl<'a> T+'a { impl T for int {} fn main() { - let x = &42i; - x.foo(); //~ERROR: type `&int` does not implement any method in scope named `foo` + let x = &42is; + x.foo(); //~ERROR: type `&isize` does not implement any method in scope named `foo` } diff --git a/src/test/compile-fail/tuple-arity-mismatch.rs b/src/test/compile-fail/tuple-arity-mismatch.rs index d0c2faed4b29d..7f073a7bfdbba 100644 --- a/src/test/compile-fail/tuple-arity-mismatch.rs +++ b/src/test/compile-fail/tuple-arity-mismatch.rs @@ -10,12 +10,12 @@ // Issue #6155 -fn first((value, _): (int, f64)) -> int { value } +fn first((value, _): (isize, f64)) -> isize { value } fn main() { let y = first ((1,2.0,3)); //~^ ERROR expected a tuple with 2 elements, found one with 3 elements let y = first ((1,)); - //~^ ERROR expected `(int, f64)`, found `(int,)` + //~^ ERROR expected `(isize, f64)`, found `(isize,)` } diff --git a/src/test/compile-fail/tuple-index-out-of-bounds.rs b/src/test/compile-fail/tuple-index-out-of-bounds.rs index 609e34f2274b7..20dd71e3bdf44 100644 --- a/src/test/compile-fail/tuple-index-out-of-bounds.rs +++ b/src/test/compile-fail/tuple-index-out-of-bounds.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct Point(int, int); +struct Point(isize, isize); fn main() { let origin = Point(0, 0); @@ -16,9 +16,9 @@ fn main() { origin.1; origin.2; //~^ ERROR attempted out-of-bounds tuple index `2` on type `Point` - let tuple = (0i, 0i); + let tuple = (0is, 0is); tuple.0; tuple.1; tuple.2; - //~^ ERROR attempted out-of-bounds tuple index `2` on type `(int, int)` + //~^ ERROR attempted out-of-bounds tuple index `2` on type `(isize, isize)` } diff --git a/src/test/compile-fail/tutorial-suffix-inference-test.rs b/src/test/compile-fail/tutorial-suffix-inference-test.rs index c1be54b3f75e1..85ad302f3ed4d 100644 --- a/src/test/compile-fail/tutorial-suffix-inference-test.rs +++ b/src/test/compile-fail/tutorial-suffix-inference-test.rs @@ -21,12 +21,12 @@ fn main() { identity_u16(y); //~^ ERROR mismatched types: expected `u16`, found `i32` - let a = 3i; + let a = 3is; - fn identity_i(n: int) -> int { n } + fn identity_i(n: isize) -> int { n } identity_i(a); // ok identity_u16(a); - //~^ ERROR mismatched types: expected `u16`, found `int` + //~^ ERROR mismatched types: expected `u16`, found `isize` } diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs index 74071f2866517..8b0897565fb91 100644 --- a/src/test/compile-fail/type-mismatch-multiple.rs +++ b/src/test/compile-fail/type-mismatch-multiple.rs @@ -10,6 +10,6 @@ // Checking that the compiler reports multiple type errors at once // error-pattern:mismatched types: expected `bool` -// error-pattern:mismatched types: expected `int` +// error-pattern:mismatched types: expected `isize` -fn main() { let a: bool = 1i; let b: int = true; } +fn main() { let a: bool = 1is; let b: isize = true; } diff --git a/src/test/compile-fail/typeck_type_placeholder_mismatch.rs b/src/test/compile-fail/typeck_type_placeholder_mismatch.rs index aa7b551afc56a..92740cf5082a6 100644 --- a/src/test/compile-fail/typeck_type_placeholder_mismatch.rs +++ b/src/test/compile-fail/typeck_type_placeholder_mismatch.rs @@ -18,12 +18,12 @@ pub fn main() { } fn test1() { - let x: Foo<_> = Bar::; - //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar` - let y: Foo = x; + let x: Foo<_> = Bar::; + //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar` + let y: Foo = x; } fn test2() { - let x: Foo<_> = Bar::; - //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar` + let x: Foo<_> = Bar::; + //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar` } diff --git a/src/test/compile-fail/variadic-ffi.rs b/src/test/compile-fail/variadic-ffi.rs index 17a17dcdcf8d6..702702990c244 100644 --- a/src/test/compile-fail/variadic-ffi.rs +++ b/src/test/compile-fail/variadic-ffi.rs @@ -13,24 +13,24 @@ extern "stdcall" { } extern { - fn foo(f: int, x: u8, ...); + fn foo(f: isize, x: u8, ...); } -extern "C" fn bar(f: int, x: u8) {} +extern "C" fn bar(f: isize, x: u8) {} fn main() { unsafe { foo(); //~ ERROR: this function takes at least 2 parameters but 0 parameters were supplied foo(1); //~ ERROR: this function takes at least 2 parameters but 1 parameter was supplied - let x: unsafe extern "C" fn(f: int, x: u8) = foo; - //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(int, u8)` - // , found `unsafe extern "C" fn(int, u8, ...)` + let x: unsafe extern "C" fn(f: isize, x: u8) = foo; + //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8)` + // , found `unsafe extern "C" fn(isize, u8, ...)` // (expected non-variadic fn, found variadic function) - let y: unsafe extern "C" fn(f: int, x: u8, ...) = bar; - //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(int, u8, ...)` - // , found `extern "C" extern fn(int, u8)` + let y: unsafe extern "C" fn(f: isize, x: u8, ...) = bar; + //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8, ...)` + // , found `extern "C" extern fn(isize, u8)` // (expected variadic fn, found non-variadic function) foo(1, 2, 3f32); //~ ERROR: can't pass an f32 to variadic function, cast to c_double diff --git a/src/test/compile-fail/warn-foreign-int-types.rs b/src/test/compile-fail/warn-foreign-int-types.rs index 5f7a2f69c4f91..9ff0f011e1dc7 100644 --- a/src/test/compile-fail/warn-foreign-int-types.rs +++ b/src/test/compile-fail/warn-foreign-int-types.rs @@ -13,9 +13,9 @@ mod xx { extern { - pub fn strlen(str: *const u8) -> uint; //~ ERROR found rust type `uint` - pub fn foo(x: int, y: uint); //~ ERROR found rust type `int` - //~^ ERROR found rust type `uint` + pub fn strlen(str: *const u8) -> usize; //~ ERROR found rust type `usize` + pub fn foo(x: isize, y: usize); //~ ERROR found rust type `isize` + //~^ ERROR found rust type `usize` } } diff --git a/src/test/debuginfo/basic-types-globals-metadata.rs b/src/test/debuginfo/basic-types-globals-metadata.rs index 4251f22b29147..e9f801c5f050e 100644 --- a/src/test/debuginfo/basic-types-globals-metadata.rs +++ b/src/test/debuginfo/basic-types-globals-metadata.rs @@ -16,7 +16,7 @@ // gdb-command:whatis 'basic-types-globals-metadata::B' // gdb-check:type = bool // gdb-command:whatis 'basic-types-globals-metadata::I' -// gdb-check:type = int +// gdb-check:type = isize // gdb-command:whatis 'basic-types-globals-metadata::C' // gdb-check:type = char // gdb-command:whatis 'basic-types-globals-metadata::I8' @@ -28,7 +28,7 @@ // gdb-command:whatis 'basic-types-globals-metadata::I64' // gdb-check:type = i64 // gdb-command:whatis 'basic-types-globals-metadata::U' -// gdb-check:type = uint +// gdb-check:type = usize // gdb-command:whatis 'basic-types-globals-metadata::U8' // gdb-check:type = u8 // gdb-command:whatis 'basic-types-globals-metadata::U16' diff --git a/src/test/debuginfo/basic-types-metadata.rs b/src/test/debuginfo/basic-types-metadata.rs index 6aa228ec51bfc..5e2497043da7a 100644 --- a/src/test/debuginfo/basic-types-metadata.rs +++ b/src/test/debuginfo/basic-types-metadata.rs @@ -18,7 +18,7 @@ // gdb-command:whatis b // gdb-check:type = bool // gdb-command:whatis i -// gdb-check:type = int +// gdb-check:type = isize // gdb-command:whatis c // gdb-check:type = char // gdb-command:whatis i8 @@ -30,7 +30,7 @@ // gdb-command:whatis i64 // gdb-check:type = i64 // gdb-command:whatis u -// gdb-check:type = uint +// gdb-check:type = usize // gdb-command:whatis u8 // gdb-check:type = u8 // gdb-command:whatis u16 @@ -53,13 +53,13 @@ fn main() { let unit: () = (); let b: bool = false; - let i: int = -1; + let i: isize = -1; let c: char = 'a'; let i8: i8 = 68; let i16: i16 = -16; let i32: i32 = -32; let i64: i64 = -64; - let u: uint = 1; + let u: usize = 1; let u8: u8 = 100; let u16: u16 = 16; let u32: u32 = 32; diff --git a/src/test/debuginfo/option-like-enum.rs b/src/test/debuginfo/option-like-enum.rs index 333ad602cf130..71c235c878cc1 100644 --- a/src/test/debuginfo/option-like-enum.rs +++ b/src/test/debuginfo/option-like-enum.rs @@ -28,13 +28,13 @@ // gdb-check:$3 = {RUST$ENCODED$ENUM$1$Empty = {454545, 0x87654321, 9988}} // gdb-command:print empty_gdb->discr -// gdb-check:$4 = (int *) 0x0 +// gdb-check:$4 = (isize *) 0x0 // gdb-command:print droid // gdb-check:$5 = {RUST$ENCODED$ENUM$2$Void = {id = 675675, range = 10000001, internals = 0x43218765}} // gdb-command:print void_droid_gdb->internals -// gdb-check:$6 = (int *) 0x0 +// gdb-check:$6 = (isize *) 0x0 // gdb-command:continue @@ -81,25 +81,25 @@ // this case (by casting the value to a memory-equivalent struct). enum MoreFields<'a> { - Full(u32, &'a int, i16), + Full(u32, &'a isize, i16), Empty } struct MoreFieldsRepr<'a> { a: u32, - discr: &'a int, + discr: &'a isize, b: i16 } enum NamedFields<'a> { - Droid { id: i32, range: i64, internals: &'a int }, + Droid { id: i32, range: i64, internals: &'a isize }, Void } struct NamedFieldsRepr<'a> { id: i32, range: i64, - internals: &'a int + internals: &'a isize } fn main() { diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs index aac5824af0050..b508da73f4add 100644 --- a/src/test/debuginfo/type-names.rs +++ b/src/test/debuginfo/type-names.rs @@ -24,7 +24,7 @@ // gdb-check:type = struct GenericStruct // gdb-command:whatis generic_struct2 -// gdb-check:type = struct GenericStruct uint> +// gdb-check:type = struct GenericStruct usize> // gdb-command:whatis mod_struct // gdb-check:type = struct Struct2 @@ -79,22 +79,22 @@ // RAW POINTERS // gdb-command:whatis mut_ptr1 -// gdb-check:type = struct (*mut type-names::Struct1, int) +// gdb-check:type = struct (*mut type-names::Struct1, isize) // gdb-command:whatis mut_ptr2 -// gdb-check:type = struct (*mut int, int) +// gdb-check:type = struct (*mut isize, isize) // gdb-command:whatis mut_ptr3 -// gdb-check:type = struct (*mut type-names::Mod1::Mod2::Enum3, int) +// gdb-check:type = struct (*mut type-names::Mod1::Mod2::Enum3, isize) // gdb-command:whatis const_ptr1 -// gdb-check:type = struct (*const type-names::Struct1, int) +// gdb-check:type = struct (*const type-names::Struct1, isize) // gdb-command:whatis const_ptr2 -// gdb-check:type = struct (*const int, int) +// gdb-check:type = struct (*const isize, isize) // gdb-command:whatis const_ptr3 -// gdb-check:type = struct (*const type-names::Mod1::Mod2::Enum3, int) +// gdb-check:type = struct (*const type-names::Mod1::Mod2::Enum3, isize) // VECTORS @@ -102,10 +102,10 @@ // gdb-check:type = struct ([type-names::Struct1; 3], i16) // gdb-command:whatis fixed_size_vec2 -// gdb-check:type = struct ([uint; 3], i16) +// gdb-check:type = struct ([usize; 3], i16) // gdb-command:whatis slice1 -// gdb-check:type = struct &[uint] +// gdb-check:type = struct &[usize] // gdb-command:whatis slice2 // gdb-check:type = struct &[type-names::Mod1::Enum2] @@ -128,50 +128,50 @@ // gdb-check:type = struct &Trait2 // gdb-command:whatis generic_mut_ref_trait -// gdb-check:type = struct &mut Trait2> +// gdb-check:type = struct &mut Trait2> // BARE FUNCTIONS // gdb-command:whatis rust_fn -// gdb-check:type = struct (fn(core::option::Option, core::option::Option<&type-names::Mod1::Struct2>), uint) +// gdb-check:type = struct (fn(core::option::Option, core::option::Option<&type-names::Mod1::Struct2>), usize) // gdb-command:whatis extern_c_fn -// gdb-check:type = struct (extern "C" fn(int), uint) +// gdb-check:type = struct (extern "C" fn(isize), usize) // gdb-command:whatis unsafe_fn -// gdb-check:type = struct (unsafe fn(core::result::Result), uint) +// gdb-check:type = struct (unsafe fn(core::result::Result), usize) // gdb-command:whatis extern_stdcall_fn -// gdb-check:type = struct (extern "stdcall" fn(), uint) +// gdb-check:type = struct (extern "stdcall" fn(), usize) // gdb-command:whatis rust_fn_with_return_value -// gdb-check:type = struct (fn(f64) -> uint, uint) +// gdb-check:type = struct (fn(f64) -> usize, usize) // gdb-command:whatis extern_c_fn_with_return_value -// gdb-check:type = struct (extern "C" fn() -> type-names::Struct1, uint) +// gdb-check:type = struct (extern "C" fn() -> type-names::Struct1, usize) // gdb-command:whatis unsafe_fn_with_return_value -// gdb-check:type = struct (unsafe fn(type-names::GenericStruct) -> type-names::Mod1::Struct2, uint) +// gdb-check:type = struct (unsafe fn(type-names::GenericStruct) -> type-names::Mod1::Struct2, usize) // gdb-command:whatis extern_stdcall_fn_with_return_value -// gdb-check:type = struct (extern "stdcall" fn(Box) -> uint, uint) +// gdb-check:type = struct (extern "stdcall" fn(Box) -> usize, usize) // gdb-command:whatis generic_function_int -// gdb-check:type = struct (fn(int) -> int, uint) +// gdb-check:type = struct (fn(isize) -> isize, usize) // gdb-command:whatis generic_function_struct3 -// gdb-check:type = struct (fn(type-names::Mod1::Mod2::Struct3) -> type-names::Mod1::Mod2::Struct3, uint) +// gdb-check:type = struct (fn(type-names::Mod1::Mod2::Struct3) -> type-names::Mod1::Mod2::Struct3, usize) // gdb-command:whatis variadic_function -// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> int, uint) +// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> isize, usize) // CLOSURES // gdb-command:whatis closure1 -// gdb-check:type = struct (closure, uint) +// gdb-check:type = struct (closure, usize) // gdb-command:whatis closure2 -// gdb-check:type = struct (closure, uint) +// gdb-check:type = struct (closure, usize) #![omit_gdb_pretty_printer_section] @@ -183,7 +183,7 @@ struct GenericStruct; enum Enum1 { Variant1_1, - Variant1_2(int) + Variant1_2(isize) } mod Mod1 { @@ -209,23 +209,23 @@ mod Mod1 { trait Trait1 { } trait Trait2 { } -impl Trait1 for int {} -impl Trait2 for int {} +impl Trait1 for isize {} +impl Trait2 for isize {} -fn rust_fn(_: Option, _: Option<&Mod1::Struct2>) {} -extern "C" fn extern_c_fn(_: int) {} +fn rust_fn(_: Option, _: Option<&Mod1::Struct2>) {} +extern "C" fn extern_c_fn(_: isize) {} unsafe fn unsafe_fn(_: Result) {} extern "stdcall" fn extern_stdcall_fn() {} -fn rust_fn_with_return_value(_: f64) -> uint { 4 } +fn rust_fn_with_return_value(_: f64) -> usize { 4 } extern "C" fn extern_c_fn_with_return_value() -> Struct1 { Struct1 } unsafe fn unsafe_fn_with_return_value(_: GenericStruct) -> Mod1::Struct2 { Mod1::Struct2 } -extern "stdcall" fn extern_stdcall_fn_with_return_value(_: Box) -> uint { 0 } +extern "stdcall" fn extern_stdcall_fn_with_return_value(_: Box) -> usize { 0 } fn generic_function(x: T) -> T { x } extern { - fn printf(_:*const u8, ...) -> int; + fn printf(_:*const u8, ...) -> isize; } // In many of the cases below, the type that is actually under test is wrapped @@ -240,7 +240,7 @@ fn main() { // Structs let simple_struct = Struct1; let generic_struct1: GenericStruct = GenericStruct; - let generic_struct2: GenericStruct uint> = GenericStruct; + let generic_struct2: GenericStruct usize> = GenericStruct; let mod_struct = Mod1::Struct2; // Enums @@ -269,13 +269,13 @@ fn main() { let mut_ref2 = (&mut mut_generic_struct, 0i32); // Raw Pointers - let mut_ptr1: (*mut Struct1, int) = (ptr::null_mut(), 0); - let mut_ptr2: (*mut int, int) = (ptr::null_mut(), 0); - let mut_ptr3: (*mut Mod1::Mod2::Enum3, int) = (ptr::null_mut(), 0); + let mut_ptr1: (*mut Struct1, isize) = (ptr::null_mut(), 0); + let mut_ptr2: (*mut isize, isize) = (ptr::null_mut(), 0); + let mut_ptr3: (*mut Mod1::Mod2::Enum3, isize) = (ptr::null_mut(), 0); - let const_ptr1: (*const Struct1, int) = (ptr::null(), 0); - let const_ptr2: (*const int, int) = (ptr::null(), 0); - let const_ptr3: (*const Mod1::Mod2::Enum3, int) = (ptr::null(), 0); + let const_ptr1: (*const Struct1, isize) = (ptr::null(), 0); + let const_ptr2: (*const isize, isize) = (ptr::null(), 0); + let const_ptr3: (*const Mod1::Mod2::Enum3, isize) = (ptr::null(), 0); // Vectors let fixed_size_vec1 = ([Struct1, Struct1, Struct1], 0i16); @@ -297,7 +297,7 @@ fn main() { let mut generic_mut_ref_trait_impl = 0i; let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl) as - &mut Trait2>; + &mut Trait2>; // Bare Functions let rust_fn = (rust_fn, 0u); @@ -310,7 +310,7 @@ fn main() { let unsafe_fn_with_return_value = (unsafe_fn_with_return_value, 0u); let extern_stdcall_fn_with_return_value = (extern_stdcall_fn_with_return_value, 0u); - let generic_function_int = (generic_function::, 0u); + let generic_function_int = (generic_function::, 0u); let generic_function_struct3 = (generic_function::, 0u); let variadic_function = (printf, 0u); @@ -321,7 +321,7 @@ fn main() { // how that maps to rustc's internal representation of these forms. // Once closures have reached their 1.0 form, the tests below should // probably be expanded. - let closure1 = (|&: x:int| {}, 0u); + let closure1 = (|&: x:isize| {}, 0u); let closure2 = (|&: x:i8, y: f32| { (x as f32) + y }, 0u); zzz(); // #break diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp index 500305f597075..f20087ef677f2 100644 --- a/src/test/pretty/issue-4264.pp +++ b/src/test/pretty/issue-4264.pp @@ -20,18 +20,18 @@ // #4264 fixed-length vector types -pub fn foo(_: [int; (3 as uint)]) { } +pub fn foo(_: [isize; (3 as usize)]) { } pub fn bar() { - const FOO: uint = ((5u as uint) - (4u as uint) as uint); - let _: [(); (FOO as uint)] = ([(() as ())] as [(); 1]); + const FOO: usize = ((5us as usize) - (4us as usize) as usize); + let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]); - let _: [(); (1u as uint)] = ([(() as ())] as [(); 1]); + let _: [(); (1us as usize)] = ([(() as ())] as [(); 1]); let _ = - (((&((([(1i as int), (2 as int), (3 as int)] as [int; 3])) as - [int; 3]) as &[int; 3]) as *const _ as *const [int; 3]) as - *const [int; (3u as uint)] as *const [int; 3]); + (((&((([(1is as isize), (2 as isize), (3 as isize)] as [isize; 3])) as + [isize; 3]) as &[isize; 3]) as *const _ as *const [isize; 3]) + as *const [isize; (3us as usize)] as *const [isize; 3]); @@ -81,18 +81,19 @@ core::fmt::Arguments<'_>)) as collections::string::String); } -pub type Foo = [int; (3u as uint)]; +pub type Foo = [isize; (3us as usize)]; pub struct Bar { - pub x: [int; (3u as uint)], + pub x: [isize; (3us as usize)], } -pub struct TupleBar([int; (4u as uint)]); -pub enum Baz { BazVariant([int; (5u as uint)]), } +pub struct TupleBar([isize; (4us as usize)]); +pub enum Baz { BazVariant([isize; (5us as usize)]), } pub fn id(x: T) -> T { (x as T) } pub fn use_id() { let _ = - ((id::<[int; (3u as uint)]> as - fn([int; 3]) -> [int; 3] {id})(([(1 as int), (2 as int), - (3 as int)] as [int; 3])) as - [int; 3]); + ((id::<[isize; (3us as usize)]> as + fn([isize; 3]) -> [isize; 3] {id})(([(1 as isize), (2 as isize), + (3 as isize)] as + [isize; 3])) as + [isize; 3]); } fn main() { } diff --git a/src/test/pretty/issue-4264.rs b/src/test/pretty/issue-4264.rs index b481e109e1a3d..75be2f23c2b20 100644 --- a/src/test/pretty/issue-4264.rs +++ b/src/test/pretty/issue-4264.rs @@ -14,35 +14,35 @@ // #4264 fixed-length vector types -pub fn foo(_: [int; 3]) {} +pub fn foo(_: [isize; 3]) {} pub fn bar() { - const FOO: uint = 5u - 4u; + const FOO: usize = 5us - 4us; let _: [(); FOO] = [()]; - let _ : [(); 1u] = [()]; + let _ : [(); 1us] = [()]; - let _ = &([1i,2,3]) as *const _ as *const [int; 3u]; + let _ = &([1is,2,3]) as *const _ as *const [isize; 3us]; format!("test"); } -pub type Foo = [int; 3u]; +pub type Foo = [isize; 3us]; pub struct Bar { - pub x: [int; 3u] + pub x: [isize; 3us] } -pub struct TupleBar([int; 4u]); +pub struct TupleBar([isize; 4us]); pub enum Baz { - BazVariant([int; 5u]) + BazVariant([isize; 5us]) } pub fn id(x: T) -> T { x } pub fn use_id() { - let _ = id::<[int; 3u]>([1,2,3]); + let _ = id::<[isize; 3us]>([1,2,3]); } diff --git a/src/test/run-make/graphviz-flowgraph/f01.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f01.dot-expected.dot index c5455ab90dc8b..694a06ed83a6f 100644 --- a/src/test/run-make/graphviz-flowgraph/f01.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f01.dot-expected.dot @@ -1,9 +1,9 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 1i"]; - N3[label="stmt 1i;"]; - N4[label="block { 1i; }"]; + N2[label="expr 1is"]; + N3[label="stmt 1is;"]; + N4[label="block { 1is; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f03.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f03.dot-expected.dot index 1986c27ad439b..efa2c6404a25f 100644 --- a/src/test/run-make/graphviz-flowgraph/f03.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f03.dot-expected.dot @@ -1,11 +1,11 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 3i"]; + N2[label="expr 3is"]; N3[label="expr 4"]; - N4[label="expr 3i + 4"]; - N5[label="stmt 3i + 4;"]; - N6[label="block { 3i + 4; }"]; + N4[label="expr 3is + 4"]; + N5[label="stmt 3is + 4;"]; + N6[label="block { 3is + 4; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f04.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f04.dot-expected.dot index 82cdcb39fbfd4..1f375b767ce49 100644 --- a/src/test/run-make/graphviz-flowgraph/f04.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f04.dot-expected.dot @@ -1,10 +1,10 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 4i"]; + N2[label="expr 4is"]; N3[label="local _x"]; - N4[label="stmt let _x = 4i;"]; - N5[label="block { let _x = 4i; }"]; + N4[label="stmt let _x = 4is;"]; + N5[label="block { let _x = 4is; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f05.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f05.dot-expected.dot index 8a27d536ffc80..8c9a930098aa6 100644 --- a/src/test/run-make/graphviz-flowgraph/f05.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f05.dot-expected.dot @@ -1,14 +1,14 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 5i"]; - N3[label="expr 55i"]; - N4[label="expr (5i, 55i)"]; + N2[label="expr 5is"]; + N3[label="expr 55is"]; + N4[label="expr (5is, 55is)"]; N5[label="local _x"]; N6[label="local _y"]; N7[label="pat (_x, _y)"]; - N8[label="stmt let (_x, _y) = (5i, 55i);"]; - N9[label="block { let (_x, _y) = (5i, 55i); }"]; + N8[label="stmt let (_x, _y) = (5is, 55is);"]; + N9[label="block { let (_x, _y) = (5is, 55is); }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot index 4c6383324e5f9..da7d5759b7ede 100644 --- a/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot @@ -1,12 +1,12 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 7i"]; - N3[label="expr 77i"]; - N4[label="expr 777i"]; - N5[label="expr 7777i"]; - N6[label="expr [7i, 77i, 777i, 7777i]"]; - N7[label="expr match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, }"]; + N2[label="expr 7is"]; + N3[label="expr 77is"]; + N4[label="expr 777is"]; + N5[label="expr 7777is"]; + N6[label="expr [7is, 77is, 777is, 7777is]"]; + N7[label="expr match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, }"]; N8[label="(dummy_node)"]; N9[label="local x"]; N10[label="local y"]; @@ -15,8 +15,8 @@ digraph block { N13[label="expr x"]; N14[label="expr y"]; N15[label="expr x + y"]; - N16[label="stmt match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, };"]; - N17[label="block { match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, }; }"]; + N16[label="stmt match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, };"]; + N17[label="block { match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, }; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f08.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f08.dot-expected.dot index 27a240ed18255..ac1972424dc95 100644 --- a/src/test/run-make/graphviz-flowgraph/f08.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f08.dot-expected.dot @@ -1,21 +1,21 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 8i"]; + N2[label="expr 8is"]; N3[label="local x"]; - N4[label="stmt let x = 8i;"]; + N4[label="stmt let x = 8is;"]; N5[label="local _y"]; N6[label="stmt let _y;"]; N7[label="expr x"]; - N8[label="expr 88i"]; - N9[label="expr x > 88i"]; - N10[label="expr 888i"]; + N8[label="expr 88is"]; + N9[label="expr x > 88is"]; + N10[label="expr 888is"]; N11[label="expr _y"]; - N12[label="expr _y = 888i"]; - N13[label="stmt _y = 888i;"]; - N14[label="block { _y = 888i; }"]; - N15[label="expr if x > 88i { _y = 888i; }"]; - N16[label="block { let x = 8i; let _y; if x > 88i { _y = 888i; } }"]; + N12[label="expr _y = 888is"]; + N13[label="stmt _y = 888is;"]; + N14[label="block { _y = 888is; }"]; + N15[label="expr if x > 88is { _y = 888is; }"]; + N16[label="block { let x = 8is; let _y; if x > 88is { _y = 888is; } }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f09.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f09.dot-expected.dot index d2c58c6d59aeb..0dc3ff14fba75 100644 --- a/src/test/run-make/graphviz-flowgraph/f09.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f09.dot-expected.dot @@ -1,29 +1,29 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 91i"]; + N2[label="expr 91is"]; N3[label="local x"]; - N4[label="stmt let x = 91i;"]; + N4[label="stmt let x = 91is;"]; N5[label="local _y"]; N6[label="stmt let _y;"]; N7[label="expr x"]; - N8[label="expr 92i"]; - N9[label="expr x > 92i"]; - N10[label="expr 93i"]; + N8[label="expr 92is"]; + N9[label="expr x > 92is"]; + N10[label="expr 93is"]; N11[label="expr _y"]; - N12[label="expr _y = 93i"]; - N13[label="stmt _y = 93i;"]; - N14[label="block { _y = 93i; }"]; - N15[label="expr 94i"]; - N16[label="expr 95i"]; - N17[label="expr 94i + 95i"]; + N12[label="expr _y = 93is"]; + N13[label="stmt _y = 93is;"]; + N14[label="block { _y = 93is; }"]; + N15[label="expr 94is"]; + N16[label="expr 95is"]; + N17[label="expr 94is + 95is"]; N18[label="expr _y"]; - N19[label="expr _y = 94i + 95i"]; - N20[label="stmt _y = 94i + 95i;"]; - N21[label="block { _y = 94i + 95i; }"]; - N22[label="expr { _y = 94i + 95i; }"]; - N23[label="expr if x > 92i { _y = 93i; } else { _y = 94i + 95i; }"]; - N24[label="block { let x = 91i; let _y; if x > 92i { _y = 93i; } else { _y = 94i + 95i; } }"]; + N19[label="expr _y = 94is + 95is"]; + N20[label="stmt _y = 94is + 95is;"]; + N21[label="block { _y = 94is + 95is; }"]; + N22[label="expr { _y = 94is + 95is; }"]; + N23[label="expr if x > 92is { _y = 93is; } else { _y = 94is + 95is; }"]; + N24[label="block {\l let x = 91is;\l let _y;\l if x > 92is { _y = 93is; } else { _y = 94is + 95is; }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f09.rs b/src/test/run-make/graphviz-flowgraph/f09.rs index cfe5f4f37d60f..184772e7d5166 100644 --- a/src/test/run-make/graphviz-flowgraph/f09.rs +++ b/src/test/run-make/graphviz-flowgraph/f09.rs @@ -9,10 +9,10 @@ // except according to those terms. pub fn expr_if_twoarm_9() { - let x = 91i; let _y; - if x > 92i { - _y = 93i; + let x = 91is; let _y; + if x > 92is { + _y = 93is; } else { - _y = 94i+95i; + _y = 94is+95is; } } diff --git a/src/test/run-make/graphviz-flowgraph/f10.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f10.dot-expected.dot index 421a79fd136b3..37606ddac70f7 100644 --- a/src/test/run-make/graphviz-flowgraph/f10.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f10.dot-expected.dot @@ -1,20 +1,20 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 10i"]; + N2[label="expr 10is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 10i;"]; + N4[label="stmt let mut x = 10is;"]; N5[label="(dummy_node)"]; N6[label="expr x"]; - N7[label="expr 0i"]; - N8[label="expr x > 0i"]; - N9[label="expr while x > 0i { x -= 1i; }"]; - N10[label="expr 1i"]; + N7[label="expr 0is"]; + N8[label="expr x > 0is"]; + N9[label="expr while x > 0is { x -= 1is; }"]; + N10[label="expr 1is"]; N11[label="expr x"]; - N12[label="expr x -= 1i"]; - N13[label="stmt x -= 1i;"]; - N14[label="block { x -= 1i; }"]; - N15[label="block { let mut x = 10i; while x > 0i { x -= 1i; } }"]; + N12[label="expr x -= 1is"]; + N13[label="stmt x -= 1is;"]; + N14[label="block { x -= 1is; }"]; + N15[label="block { let mut x = 10is; while x > 0is { x -= 1is; } }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f11.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f11.dot-expected.dot index b928058fed99c..39a55f1a0926b 100644 --- a/src/test/run-make/graphviz-flowgraph/f11.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f11.dot-expected.dot @@ -1,20 +1,20 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 11i"]; + N2[label="expr 11is"]; N3[label="local mut _x"]; - N4[label="stmt let mut _x = 11i;"]; + N4[label="stmt let mut _x = 11is;"]; N5[label="(dummy_node)"]; - N6[label="expr loop { _x -= 1i; }"]; - N7[label="expr 1i"]; + N6[label="expr loop { _x -= 1is; }"]; + N7[label="expr 1is"]; N8[label="expr _x"]; - N9[label="expr _x -= 1i"]; - N10[label="stmt _x -= 1i;"]; - N11[label="block { _x -= 1i; }"]; - N12[label="stmt loop { _x -= 1i; }"]; + N9[label="expr _x -= 1is"]; + N10[label="stmt _x -= 1is;"]; + N11[label="block { _x -= 1is; }"]; + N12[label="stmt loop { _x -= 1is; }"]; N13[label="expr \"unreachable\""]; N14[label="stmt \"unreachable\";"]; - N15[label="block { let mut _x = 11i; loop { _x -= 1i; } \"unreachable\"; }"]; + N15[label="block { let mut _x = 11is; loop { _x -= 1is; } \"unreachable\"; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f12.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f12.dot-expected.dot index d89a37308de06..e9cd07c0356f8 100644 --- a/src/test/run-make/graphviz-flowgraph/f12.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f12.dot-expected.dot @@ -1,27 +1,27 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 12i"]; + N2[label="expr 12is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 12i;"]; + N4[label="stmt let mut x = 12is;"]; N5[label="(dummy_node)"]; - N6[label="expr loop { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"]; - N7[label="expr 1i"]; + N6[label="expr loop { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"]; + N7[label="expr 1is"]; N8[label="expr x"]; - N9[label="expr x -= 1i"]; - N10[label="stmt x -= 1i;"]; + N9[label="expr x -= 1is"]; + N10[label="stmt x -= 1is;"]; N11[label="expr x"]; - N12[label="expr 2i"]; - N13[label="expr x == 2i"]; + N12[label="expr 2is"]; + N13[label="expr x == 2is"]; N14[label="expr break"]; N15[label="(dummy_node)"]; N16[label="stmt break ;"]; N17[label="expr \"unreachable\""]; N18[label="stmt \"unreachable\";"]; N19[label="block { break ; \"unreachable\"; }"]; - N20[label="expr if x == 2i { break ; \"unreachable\"; }"]; - N21[label="block { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"]; - N22[label="block { let mut x = 12i; loop { x -= 1i; if x == 2i { break ; \"unreachable\"; } } }"]; + N20[label="expr if x == 2is { break ; \"unreachable\"; }"]; + N21[label="block { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"]; + N22[label="block {\l let mut x = 12is;\l loop { x -= 1is; if x == 2is { break ; \"unreachable\"; } }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -34,7 +34,7 @@ digraph block { N11 -> N12; N12 -> N13; N13 -> N14; - N14 -> N6[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 2i { break ; \"unreachable\"; },\lexiting scope_4 block { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"]; + N14 -> N6[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 2is { break ; \"unreachable\"; },\lexiting scope_4 block { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"]; N15 -> N16; N16 -> N17; N17 -> N18; diff --git a/src/test/run-make/graphviz-flowgraph/f14.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f14.dot-expected.dot index bdb2c133badf8..ac1a631eb56ed 100644 --- a/src/test/run-make/graphviz-flowgraph/f14.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f14.dot-expected.dot @@ -1,20 +1,20 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 14i"]; + N2[label="expr 14is"]; N3[label="local x"]; - N4[label="stmt let x = 14i;"]; + N4[label="stmt let x = 14is;"]; N5[label="expr x"]; - N6[label="expr 1i"]; - N7[label="expr x > 1i"]; + N6[label="expr 1is"]; + N7[label="expr x > 1is"]; N8[label="expr return"]; N9[label="(dummy_node)"]; N10[label="stmt return;"]; N11[label="expr \"unreachable\""]; N12[label="stmt \"unreachable\";"]; N13[label="block { return; \"unreachable\"; }"]; - N14[label="expr if x > 1i { return; \"unreachable\"; }"]; - N15[label="block { let x = 14i; if x > 1i { return; \"unreachable\"; } }"]; + N14[label="expr if x > 1is { return; \"unreachable\"; }"]; + N15[label="block { let x = 14is; if x > 1is { return; \"unreachable\"; } }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f15.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f15.dot-expected.dot index 4bd9fc9ec1ad1..7b01c606083ff 100644 --- a/src/test/run-make/graphviz-flowgraph/f15.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f15.dot-expected.dot @@ -1,54 +1,54 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 15i"]; + N2[label="expr 15is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 15i;"]; - N5[label="expr 151i"]; + N4[label="stmt let mut x = 15is;"]; + N5[label="expr 151is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 151i;"]; + N7[label="stmt let mut y = 151is;"]; N8[label="(dummy_node)"]; - N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l }\l"]; + N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l }\l"]; N10[label="(dummy_node)"]; - N11[label="expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l"]; + N11[label="expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l"]; N12[label="expr x"]; - N13[label="expr 1i"]; - N14[label="expr x == 1i"]; + N13[label="expr 1is"]; + N14[label="expr x == 1is"]; N15[label="expr break \'outer"]; N16[label="(dummy_node)"]; N17[label="stmt break \'outer ;"]; N18[label="expr \"unreachable\""]; N19[label="stmt \"unreachable\";"]; N20[label="block { break \'outer ; \"unreachable\"; }"]; - N21[label="expr if x == 1i { break \'outer ; \"unreachable\"; }"]; - N22[label="stmt if x == 1i { break \'outer ; \"unreachable\"; }"]; + N21[label="expr if x == 1is { break \'outer ; \"unreachable\"; }"]; + N22[label="stmt if x == 1is { break \'outer ; \"unreachable\"; }"]; N23[label="expr y"]; - N24[label="expr 2i"]; - N25[label="expr y >= 2i"]; + N24[label="expr 2is"]; + N25[label="expr y >= 2is"]; N26[label="expr break"]; N27[label="(dummy_node)"]; N28[label="stmt break ;"]; N29[label="expr \"unreachable\""]; N30[label="stmt \"unreachable\";"]; N31[label="block { break ; \"unreachable\"; }"]; - N32[label="expr if y >= 2i { break ; \"unreachable\"; }"]; - N33[label="stmt if y >= 2i { break ; \"unreachable\"; }"]; - N34[label="expr 3i"]; + N32[label="expr if y >= 2is { break ; \"unreachable\"; }"]; + N33[label="stmt if y >= 2is { break ; \"unreachable\"; }"]; + N34[label="expr 3is"]; N35[label="expr y"]; - N36[label="expr y -= 3i"]; - N37[label="stmt y -= 3i;"]; - N38[label="block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l"]; - N39[label="stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l"]; - N40[label="expr 4i"]; + N36[label="expr y -= 3is"]; + N37[label="stmt y -= 3is;"]; + N38[label="block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l"]; + N39[label="stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l"]; + N40[label="expr 4is"]; N41[label="expr y"]; - N42[label="expr y -= 4i"]; - N43[label="stmt y -= 4i;"]; - N44[label="expr 5i"]; + N42[label="expr y -= 4is"]; + N43[label="stmt y -= 4is;"]; + N44[label="expr 5is"]; N45[label="expr x"]; - N46[label="expr x -= 5i"]; - N47[label="stmt x -= 5i;"]; - N48[label="block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l}\l"]; - N49[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l }\l}\l"]; + N46[label="expr x -= 5is"]; + N47[label="stmt x -= 5is;"]; + N48[label="block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l}\l"]; + N49[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -61,7 +61,7 @@ digraph block { N12 -> N13; N13 -> N14; N14 -> N15; - N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l}\l"]; + N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l}\l"]; N16 -> N17; N17 -> N18; N18 -> N19; @@ -73,7 +73,7 @@ digraph block { N23 -> N24; N24 -> N25; N25 -> N26; - N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 2i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 2i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l"]; + N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 2is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 2is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l"]; N27 -> N28; N28 -> N29; N29 -> N30; diff --git a/src/test/run-make/graphviz-flowgraph/f16.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f16.dot-expected.dot index 16b871bd844bf..2123185a08386 100644 --- a/src/test/run-make/graphviz-flowgraph/f16.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f16.dot-expected.dot @@ -1,57 +1,57 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 16i"]; + N2[label="expr 16is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 16i;"]; - N5[label="expr 16i"]; + N4[label="stmt let mut x = 16is;"]; + N5[label="expr 16is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 16i;"]; + N7[label="stmt let mut y = 16is;"]; N8[label="(dummy_node)"]; - N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l"]; + N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l"]; N10[label="(dummy_node)"]; - N11[label="expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l"]; + N11[label="expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l"]; N12[label="expr x"]; - N13[label="expr 1i"]; - N14[label="expr x == 1i"]; + N13[label="expr 1is"]; + N14[label="expr x == 1is"]; N15[label="expr continue \'outer"]; N16[label="(dummy_node)"]; N17[label="stmt continue \'outer ;"]; N18[label="expr \"unreachable\""]; N19[label="stmt \"unreachable\";"]; N20[label="block { continue \'outer ; \"unreachable\"; }"]; - N21[label="expr if x == 1i { continue \'outer ; \"unreachable\"; }"]; - N22[label="stmt if x == 1i { continue \'outer ; \"unreachable\"; }"]; + N21[label="expr if x == 1is { continue \'outer ; \"unreachable\"; }"]; + N22[label="stmt if x == 1is { continue \'outer ; \"unreachable\"; }"]; N23[label="expr y"]; - N24[label="expr 1i"]; - N25[label="expr y >= 1i"]; + N24[label="expr 1is"]; + N25[label="expr y >= 1is"]; N26[label="expr break"]; N27[label="(dummy_node)"]; N28[label="stmt break ;"]; N29[label="expr \"unreachable\""]; N30[label="stmt \"unreachable\";"]; N31[label="block { break ; \"unreachable\"; }"]; - N32[label="expr if y >= 1i { break ; \"unreachable\"; }"]; - N33[label="stmt if y >= 1i { break ; \"unreachable\"; }"]; - N34[label="expr 1i"]; + N32[label="expr if y >= 1is { break ; \"unreachable\"; }"]; + N33[label="stmt if y >= 1is { break ; \"unreachable\"; }"]; + N34[label="expr 1is"]; N35[label="expr y"]; - N36[label="expr y -= 1i"]; - N37[label="stmt y -= 1i;"]; - N38[label="block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l"]; - N39[label="stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l"]; - N40[label="expr 1i"]; + N36[label="expr y -= 1is"]; + N37[label="stmt y -= 1is;"]; + N38[label="block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l"]; + N39[label="stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l"]; + N40[label="expr 1is"]; N41[label="expr y"]; - N42[label="expr y -= 1i"]; - N43[label="stmt y -= 1i;"]; - N44[label="expr 1i"]; + N42[label="expr y -= 1is"]; + N43[label="stmt y -= 1is;"]; + N44[label="expr 1is"]; N45[label="expr x"]; - N46[label="expr x -= 1i"]; - N47[label="stmt x -= 1i;"]; - N48[label="block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l}\l"]; - N49[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l"]; + N46[label="expr x -= 1is"]; + N47[label="stmt x -= 1is;"]; + N48[label="block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l}\l"]; + N49[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l"]; N50[label="expr \"unreachable\""]; N51[label="stmt \"unreachable\";"]; - N52[label="block {\l let mut x = 16i;\l let mut y = 16i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l \"unreachable\";\l}\l"]; + N52[label="block {\l let mut x = 16is;\l let mut y = 16is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l \"unreachable\";\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -64,7 +64,7 @@ digraph block { N12 -> N13; N13 -> N14; N14 -> N15; - N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l}\l"]; + N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l}\l"]; N16 -> N17; N17 -> N18; N18 -> N19; @@ -76,7 +76,7 @@ digraph block { N23 -> N24; N24 -> N25; N25 -> N26; - N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 1i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 1i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l"]; + N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 1is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 1is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l"]; N27 -> N28; N28 -> N29; N29 -> N30; diff --git a/src/test/run-make/graphviz-flowgraph/f17.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f17.dot-expected.dot index c78224c00df8a..7941b4f7ce540 100644 --- a/src/test/run-make/graphviz-flowgraph/f17.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f17.dot-expected.dot @@ -1,13 +1,13 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 1i"]; - N3[label="expr 7i"]; - N4[label="expr 17i"]; - N5[label="expr [1i, 7i, 17i]"]; + N2[label="expr 1is"]; + N3[label="expr 7is"]; + N4[label="expr 17is"]; + N5[label="expr [1is, 7is, 17is]"]; N6[label="local _v"]; - N7[label="stmt let _v = [1i, 7i, 17i];"]; - N8[label="block { let _v = [1i, 7i, 17i]; }"]; + N7[label="stmt let _v = [1is, 7is, 17is];"]; + N8[label="block { let _v = [1is, 7is, 17is]; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot index a625a1a0026fa..c9e4b41c81269 100644 --- a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot @@ -1,17 +1,17 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 2u"]; - N3[label="expr 0u"]; - N4[label="expr 20u"]; - N5[label="expr [2u, 0u, 20u]"]; + N2[label="expr 2us"]; + N3[label="expr 0us"]; + N4[label="expr 20us"]; + N5[label="expr [2us, 0us, 20us]"]; N6[label="local v"]; - N7[label="stmt let v = [2u, 0u, 20u];"]; + N7[label="stmt let v = [2us, 0us, 20us];"]; N8[label="expr v"]; - N9[label="expr 20u"]; - N10[label="expr v[20u]"]; - N11[label="stmt v[20u];"]; - N12[label="block { let v = [2u, 0u, 20u]; v[20u]; }"]; + N9[label="expr 20us"]; + N10[label="expr v[20us]"]; + N11[label="stmt v[20us];"]; + N12[label="block { let v = [2us, 0us, 20us]; v[20us]; }"]; N0 -> N2; N2 -> N3; N3 -> N4; diff --git a/src/test/run-make/graphviz-flowgraph/f21.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f21.dot-expected.dot index ad2ef60ce2918..e7a2cf2ff732f 100644 --- a/src/test/run-make/graphviz-flowgraph/f21.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f21.dot-expected.dot @@ -1,52 +1,52 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 15i"]; + N2[label="expr 15is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 15i;"]; - N5[label="expr 151i"]; + N4[label="stmt let mut x = 15is;"]; + N5[label="expr 151is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 151i;"]; + N7[label="stmt let mut y = 151is;"]; N8[label="(dummy_node)"]; - N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l"]; + N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l"]; N10[label="(dummy_node)"]; - N11[label="expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l"]; + N11[label="expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l"]; N12[label="expr x"]; - N13[label="expr 1i"]; - N14[label="expr x == 1i"]; + N13[label="expr 1is"]; + N14[label="expr x == 1is"]; N15[label="expr break \'outer"]; N16[label="(dummy_node)"]; N17[label="stmt break \'outer ;"]; N18[label="expr \"unreachable\""]; N19[label="stmt \"unreachable\";"]; N20[label="block { break \'outer ; \"unreachable\"; }"]; - N21[label="expr if x == 1i { break \'outer ; \"unreachable\"; }"]; - N22[label="stmt if x == 1i { break \'outer ; \"unreachable\"; }"]; + N21[label="expr if x == 1is { break \'outer ; \"unreachable\"; }"]; + N22[label="stmt if x == 1is { break \'outer ; \"unreachable\"; }"]; N23[label="expr y"]; - N24[label="expr 2i"]; - N25[label="expr y >= 2i"]; + N24[label="expr 2is"]; + N25[label="expr y >= 2is"]; N26[label="expr return"]; N27[label="(dummy_node)"]; N28[label="stmt return;"]; N29[label="expr \"unreachable\""]; N30[label="stmt \"unreachable\";"]; N31[label="block { return; \"unreachable\"; }"]; - N32[label="expr if y >= 2i { return; \"unreachable\"; }"]; - N33[label="stmt if y >= 2i { return; \"unreachable\"; }"]; - N34[label="expr 3i"]; + N32[label="expr if y >= 2is { return; \"unreachable\"; }"]; + N33[label="stmt if y >= 2is { return; \"unreachable\"; }"]; + N34[label="expr 3is"]; N35[label="expr y"]; - N36[label="expr y -= 3i"]; - N37[label="stmt y -= 3i;"]; - N38[label="expr 5i"]; + N36[label="expr y -= 3is"]; + N37[label="stmt y -= 3is;"]; + N38[label="expr 5is"]; N39[label="expr x"]; - N40[label="expr x -= 5i"]; - N41[label="stmt x -= 5i;"]; - N42[label="block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l}\l"]; - N43[label="stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l"]; + N40[label="expr x -= 5is"]; + N41[label="stmt x -= 5is;"]; + N42[label="block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l}\l"]; + N43[label="stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l"]; N44[label="expr \"unreachable\""]; N45[label="stmt \"unreachable\";"]; - N46[label="block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l}\l"]; - N47[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l}\l"]; + N46[label="block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l}\l"]; + N47[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -59,7 +59,7 @@ digraph block { N12 -> N13; N13 -> N14; N14 -> N15; - N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l}\l"]; + N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l}\l"]; N16 -> N17; N17 -> N18; N18 -> N19; @@ -71,7 +71,7 @@ digraph block { N23 -> N24; N24 -> N25; N25 -> N26; - N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l"]; + N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l"]; N27 -> N28; N28 -> N29; N29 -> N30; diff --git a/src/test/run-make/graphviz-flowgraph/f22.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f22.dot-expected.dot index dcceb5bb937da..edd39b40b36a3 100644 --- a/src/test/run-make/graphviz-flowgraph/f22.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f22.dot-expected.dot @@ -1,55 +1,55 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 15i"]; + N2[label="expr 15is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 15i;"]; - N5[label="expr 151i"]; + N4[label="stmt let mut x = 15is;"]; + N5[label="expr 151is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 151i;"]; + N7[label="stmt let mut y = 151is;"]; N8[label="(dummy_node)"]; - N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"]; + N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"]; N10[label="(dummy_node)"]; - N11[label="expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l"]; + N11[label="expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l"]; N12[label="expr x"]; - N13[label="expr 1i"]; - N14[label="expr x == 1i"]; + N13[label="expr 1is"]; + N14[label="expr x == 1is"]; N15[label="expr continue \'outer"]; N16[label="(dummy_node)"]; N17[label="stmt continue \'outer ;"]; N18[label="expr \"unreachable\""]; N19[label="stmt \"unreachable\";"]; N20[label="block { continue \'outer ; \"unreachable\"; }"]; - N21[label="expr if x == 1i { continue \'outer ; \"unreachable\"; }"]; - N22[label="stmt if x == 1i { continue \'outer ; \"unreachable\"; }"]; + N21[label="expr if x == 1is { continue \'outer ; \"unreachable\"; }"]; + N22[label="stmt if x == 1is { continue \'outer ; \"unreachable\"; }"]; N23[label="expr y"]; - N24[label="expr 2i"]; - N25[label="expr y >= 2i"]; + N24[label="expr 2is"]; + N25[label="expr y >= 2is"]; N26[label="expr return"]; N27[label="(dummy_node)"]; N28[label="stmt return;"]; N29[label="expr \"unreachable\""]; N30[label="stmt \"unreachable\";"]; N31[label="block { return; \"unreachable\"; }"]; - N32[label="expr if y >= 2i { return; \"unreachable\"; }"]; - N33[label="stmt if y >= 2i { return; \"unreachable\"; }"]; - N34[label="expr 1i"]; + N32[label="expr if y >= 2is { return; \"unreachable\"; }"]; + N33[label="stmt if y >= 2is { return; \"unreachable\"; }"]; + N34[label="expr 1is"]; N35[label="expr x"]; - N36[label="expr x -= 1i"]; - N37[label="stmt x -= 1i;"]; - N38[label="expr 3i"]; + N36[label="expr x -= 1is"]; + N37[label="stmt x -= 1is;"]; + N38[label="expr 3is"]; N39[label="expr y"]; - N40[label="expr y -= 3i"]; - N41[label="stmt y -= 3i;"]; - N42[label="block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l}\l"]; - N43[label="stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l"]; + N40[label="expr y -= 3is"]; + N41[label="stmt y -= 3is;"]; + N42[label="block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l}\l"]; + N43[label="stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l"]; N44[label="expr \"unreachable\""]; N45[label="stmt \"unreachable\";"]; - N46[label="block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l}\l"]; - N47[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"]; + N46[label="block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l}\l"]; + N47[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"]; N48[label="expr \"unreachable\""]; N49[label="stmt \"unreachable\";"]; - N50[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l \"unreachable\";\l}\l"]; + N50[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l \"unreachable\";\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -62,7 +62,7 @@ digraph block { N12 -> N13; N13 -> N14; N14 -> N15; - N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l}\l"]; + N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l}\l"]; N16 -> N17; N17 -> N18; N18 -> N19; @@ -74,7 +74,7 @@ digraph block { N23 -> N24; N24 -> N25; N25 -> N26; - N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"]; + N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"]; N27 -> N28; N28 -> N29; N29 -> N30; diff --git a/src/test/run-make/graphviz-flowgraph/f23.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f23.dot-expected.dot index 034ecfb7f2099..2b5c5cdff44e3 100644 --- a/src/test/run-make/graphviz-flowgraph/f23.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f23.dot-expected.dot @@ -1,57 +1,57 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 23i"]; + N2[label="expr 23is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 23i;"]; - N5[label="expr 23i"]; + N4[label="stmt let mut x = 23is;"]; + N5[label="expr 23is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 23i;"]; - N8[label="expr 23i"]; + N7[label="stmt let mut y = 23is;"]; + N8[label="expr 23is"]; N9[label="local mut z"]; - N10[label="stmt let mut z = 23i;"]; + N10[label="stmt let mut z = 23is;"]; N11[label="(dummy_node)"]; N12[label="expr x"]; - N13[label="expr 0i"]; - N14[label="expr x > 0i"]; - N15[label="expr while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; - N16[label="expr 1i"]; + N13[label="expr 0is"]; + N14[label="expr x > 0is"]; + N15[label="expr while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; + N16[label="expr 1is"]; N17[label="expr x"]; - N18[label="expr x -= 1i"]; - N19[label="stmt x -= 1i;"]; + N18[label="expr x -= 1is"]; + N19[label="stmt x -= 1is;"]; N20[label="(dummy_node)"]; N21[label="expr y"]; - N22[label="expr 0i"]; - N23[label="expr y > 0i"]; - N24[label="expr while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"]; - N25[label="expr 1i"]; + N22[label="expr 0is"]; + N23[label="expr y > 0is"]; + N24[label="expr while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"]; + N25[label="expr 1is"]; N26[label="expr y"]; - N27[label="expr y -= 1i"]; - N28[label="stmt y -= 1i;"]; + N27[label="expr y -= 1is"]; + N28[label="stmt y -= 1is;"]; N29[label="(dummy_node)"]; N30[label="expr z"]; - N31[label="expr 0i"]; - N32[label="expr z > 0i"]; - N33[label="expr while z > 0i { z -= 1i; }"]; - N34[label="expr 1i"]; + N31[label="expr 0is"]; + N32[label="expr z > 0is"]; + N33[label="expr while z > 0is { z -= 1is; }"]; + N34[label="expr 1is"]; N35[label="expr z"]; - N36[label="expr z -= 1i"]; - N37[label="stmt z -= 1i;"]; - N38[label="block { z -= 1i; }"]; - N39[label="stmt while z > 0i { z -= 1i; }"]; + N36[label="expr z -= 1is"]; + N37[label="stmt z -= 1is;"]; + N38[label="block { z -= 1is; }"]; + N39[label="stmt while z > 0is { z -= 1is; }"]; N40[label="expr x"]; - N41[label="expr 10i"]; - N42[label="expr x > 10i"]; + N41[label="expr 10is"]; + N42[label="expr x > 10is"]; N43[label="expr return"]; N44[label="(dummy_node)"]; N45[label="stmt return;"]; N46[label="expr \"unreachable\""]; N47[label="stmt \"unreachable\";"]; N48[label="block { return; \"unreachable\"; }"]; - N49[label="expr if x > 10i { return; \"unreachable\"; }"]; - N50[label="block { y -= 1i; while z > 0i { z -= 1i; } if x > 10i { return; \"unreachable\"; } }"]; - N51[label="block {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; - N52[label="block {\l let mut x = 23i;\l let mut y = 23i;\l let mut z = 23i;\l while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l }\l}\l"]; + N49[label="expr if x > 10is { return; \"unreachable\"; }"]; + N50[label="block {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"]; + N51[label="block {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; + N52[label="block {\l let mut x = 23is;\l let mut y = 23is;\l let mut z = 23is;\l while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -95,7 +95,7 @@ digraph block { N40 -> N41; N41 -> N42; N42 -> N43; - N43 -> N1[label="exiting scope_0 expr while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; + N43 -> N1[label="exiting scope_0 expr while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; N44 -> N45; N45 -> N46; N46 -> N47; diff --git a/src/test/run-make/graphviz-flowgraph/f24.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f24.dot-expected.dot index ddb5b865c2edb..ee3fe7ced6cd7 100644 --- a/src/test/run-make/graphviz-flowgraph/f24.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f24.dot-expected.dot @@ -1,81 +1,81 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 24i"]; + N2[label="expr 24is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 24i;"]; - N5[label="expr 24i"]; + N4[label="stmt let mut x = 24is;"]; + N5[label="expr 24is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 24i;"]; - N8[label="expr 24i"]; + N7[label="stmt let mut y = 24is;"]; + N8[label="expr 24is"]; N9[label="local mut z"]; - N10[label="stmt let mut z = 24i;"]; + N10[label="stmt let mut z = 24is;"]; N11[label="(dummy_node)"]; - N12[label="expr loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; + N12[label="expr loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; N13[label="expr x"]; - N14[label="expr 0i"]; - N15[label="expr x == 0i"]; + N14[label="expr 0is"]; + N15[label="expr x == 0is"]; N16[label="expr break"]; N17[label="(dummy_node)"]; N18[label="stmt break ;"]; N19[label="expr \"unreachable\""]; N20[label="stmt \"unreachable\";"]; N21[label="block { break ; \"unreachable\"; }"]; - N22[label="expr if x == 0i { break ; \"unreachable\"; }"]; - N23[label="stmt if x == 0i { break ; \"unreachable\"; }"]; - N24[label="expr 1i"]; + N22[label="expr if x == 0is { break ; \"unreachable\"; }"]; + N23[label="stmt if x == 0is { break ; \"unreachable\"; }"]; + N24[label="expr 1is"]; N25[label="expr x"]; - N26[label="expr x -= 1i"]; - N27[label="stmt x -= 1i;"]; + N26[label="expr x -= 1is"]; + N27[label="stmt x -= 1is;"]; N28[label="(dummy_node)"]; - N29[label="expr loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"]; + N29[label="expr loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"]; N30[label="expr y"]; - N31[label="expr 0i"]; - N32[label="expr y == 0i"]; + N31[label="expr 0is"]; + N32[label="expr y == 0is"]; N33[label="expr break"]; N34[label="(dummy_node)"]; N35[label="stmt break ;"]; N36[label="expr \"unreachable\""]; N37[label="stmt \"unreachable\";"]; N38[label="block { break ; \"unreachable\"; }"]; - N39[label="expr if y == 0i { break ; \"unreachable\"; }"]; - N40[label="stmt if y == 0i { break ; \"unreachable\"; }"]; - N41[label="expr 1i"]; + N39[label="expr if y == 0is { break ; \"unreachable\"; }"]; + N40[label="stmt if y == 0is { break ; \"unreachable\"; }"]; + N41[label="expr 1is"]; N42[label="expr y"]; - N43[label="expr y -= 1i"]; - N44[label="stmt y -= 1i;"]; + N43[label="expr y -= 1is"]; + N44[label="stmt y -= 1is;"]; N45[label="(dummy_node)"]; - N46[label="expr loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N46[label="expr loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N47[label="expr z"]; - N48[label="expr 0i"]; - N49[label="expr z == 0i"]; + N48[label="expr 0is"]; + N49[label="expr z == 0is"]; N50[label="expr break"]; N51[label="(dummy_node)"]; N52[label="stmt break ;"]; N53[label="expr \"unreachable\""]; N54[label="stmt \"unreachable\";"]; N55[label="block { break ; \"unreachable\"; }"]; - N56[label="expr if z == 0i { break ; \"unreachable\"; }"]; - N57[label="stmt if z == 0i { break ; \"unreachable\"; }"]; - N58[label="expr 1i"]; + N56[label="expr if z == 0is { break ; \"unreachable\"; }"]; + N57[label="stmt if z == 0is { break ; \"unreachable\"; }"]; + N58[label="expr 1is"]; N59[label="expr z"]; - N60[label="expr z -= 1i"]; - N61[label="stmt z -= 1i;"]; - N62[label="block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; - N63[label="stmt loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N60[label="expr z -= 1is"]; + N61[label="stmt z -= 1is;"]; + N62[label="block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; + N63[label="stmt loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N64[label="expr x"]; - N65[label="expr 10i"]; - N66[label="expr x > 10i"]; + N65[label="expr 10is"]; + N66[label="expr x > 10is"]; N67[label="expr return"]; N68[label="(dummy_node)"]; N69[label="stmt return;"]; N70[label="expr \"unreachable\""]; N71[label="stmt \"unreachable\";"]; N72[label="block { return; \"unreachable\"; }"]; - N73[label="expr if x > 10i { return; \"unreachable\"; }"]; - N74[label="block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"]; - N75[label="block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; - N76[label="block {\l let mut x = 24i;\l let mut y = 24i;\l let mut z = 24i;\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l }\l}\l"]; + N73[label="expr if x > 10is { return; \"unreachable\"; }"]; + N74[label="block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"]; + N75[label="block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; + N76[label="block {\l let mut x = 24is;\l let mut y = 24is;\l let mut z = 24is;\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -90,7 +90,7 @@ digraph block { N13 -> N14; N14 -> N15; N15 -> N16; - N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; + N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; N17 -> N18; N18 -> N19; N19 -> N20; @@ -107,7 +107,7 @@ digraph block { N30 -> N31; N31 -> N32; N32 -> N33; - N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"]; + N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"]; N34 -> N35; N35 -> N36; N36 -> N37; @@ -124,7 +124,7 @@ digraph block { N47 -> N48; N48 -> N49; N49 -> N50; - N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0i { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0is { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N51 -> N52; N52 -> N53; N53 -> N54; @@ -143,7 +143,7 @@ digraph block { N64 -> N65; N65 -> N66; N66 -> N67; - N67 -> N1[label="exiting scope_0 expr loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"]; + N67 -> N1[label="exiting scope_0 expr loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"]; N68 -> N69; N69 -> N70; N70 -> N71; diff --git a/src/test/run-make/graphviz-flowgraph/f25.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f25.dot-expected.dot index 9fd4dbfc39553..82799c724b0bd 100644 --- a/src/test/run-make/graphviz-flowgraph/f25.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f25.dot-expected.dot @@ -1,81 +1,81 @@ digraph block { N0[label="entry"]; N1[label="exit"]; - N2[label="expr 25i"]; + N2[label="expr 25is"]; N3[label="local mut x"]; - N4[label="stmt let mut x = 25i;"]; - N5[label="expr 25i"]; + N4[label="stmt let mut x = 25is;"]; + N5[label="expr 25is"]; N6[label="local mut y"]; - N7[label="stmt let mut y = 25i;"]; - N8[label="expr 25i"]; + N7[label="stmt let mut y = 25is;"]; + N8[label="expr 25is"]; N9[label="local mut z"]; - N10[label="stmt let mut z = 25i;"]; + N10[label="stmt let mut z = 25is;"]; N11[label="(dummy_node)"]; - N12[label="expr \'a:\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l }\l"]; + N12[label="expr \'a:\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l }\l"]; N13[label="expr x"]; - N14[label="expr 0i"]; - N15[label="expr x == 0i"]; + N14[label="expr 0is"]; + N15[label="expr x == 0is"]; N16[label="expr break"]; N17[label="(dummy_node)"]; N18[label="stmt break ;"]; N19[label="expr \"unreachable\""]; N20[label="stmt \"unreachable\";"]; N21[label="block { break ; \"unreachable\"; }"]; - N22[label="expr if x == 0i { break ; \"unreachable\"; }"]; - N23[label="stmt if x == 0i { break ; \"unreachable\"; }"]; - N24[label="expr 1i"]; + N22[label="expr if x == 0is { break ; \"unreachable\"; }"]; + N23[label="stmt if x == 0is { break ; \"unreachable\"; }"]; + N24[label="expr 1is"]; N25[label="expr x"]; - N26[label="expr x -= 1i"]; - N27[label="stmt x -= 1i;"]; + N26[label="expr x -= 1is"]; + N27[label="stmt x -= 1is;"]; N28[label="(dummy_node)"]; - N29[label="expr \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l"]; + N29[label="expr \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l"]; N30[label="expr y"]; - N31[label="expr 0i"]; - N32[label="expr y == 0i"]; + N31[label="expr 0is"]; + N32[label="expr y == 0is"]; N33[label="expr break"]; N34[label="(dummy_node)"]; N35[label="stmt break ;"]; N36[label="expr \"unreachable\""]; N37[label="stmt \"unreachable\";"]; N38[label="block { break ; \"unreachable\"; }"]; - N39[label="expr if y == 0i { break ; \"unreachable\"; }"]; - N40[label="stmt if y == 0i { break ; \"unreachable\"; }"]; - N41[label="expr 1i"]; + N39[label="expr if y == 0is { break ; \"unreachable\"; }"]; + N40[label="stmt if y == 0is { break ; \"unreachable\"; }"]; + N41[label="expr 1is"]; N42[label="expr y"]; - N43[label="expr y -= 1i"]; - N44[label="stmt y -= 1i;"]; + N43[label="expr y -= 1is"]; + N44[label="stmt y -= 1is;"]; N45[label="(dummy_node)"]; - N46[label="expr \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N46[label="expr \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N47[label="expr z"]; - N48[label="expr 0i"]; - N49[label="expr z == 0i"]; + N48[label="expr 0is"]; + N49[label="expr z == 0is"]; N50[label="expr break"]; N51[label="(dummy_node)"]; N52[label="stmt break ;"]; N53[label="expr \"unreachable\""]; N54[label="stmt \"unreachable\";"]; N55[label="block { break ; \"unreachable\"; }"]; - N56[label="expr if z == 0i { break ; \"unreachable\"; }"]; - N57[label="stmt if z == 0i { break ; \"unreachable\"; }"]; - N58[label="expr 1i"]; + N56[label="expr if z == 0is { break ; \"unreachable\"; }"]; + N57[label="stmt if z == 0is { break ; \"unreachable\"; }"]; + N58[label="expr 1is"]; N59[label="expr z"]; - N60[label="expr z -= 1i"]; - N61[label="stmt z -= 1i;"]; - N62[label="block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; - N63[label="stmt \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N60[label="expr z -= 1is"]; + N61[label="stmt z -= 1is;"]; + N62[label="block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; + N63[label="stmt \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N64[label="expr x"]; - N65[label="expr 10i"]; - N66[label="expr x > 10i"]; + N65[label="expr 10is"]; + N66[label="expr x > 10is"]; N67[label="expr continue \'a"]; N68[label="(dummy_node)"]; N69[label="stmt continue \'a ;"]; N70[label="expr \"unreachable\""]; N71[label="stmt \"unreachable\";"]; N72[label="block { continue \'a ; \"unreachable\"; }"]; - N73[label="expr if x > 10i { continue \'a ; \"unreachable\"; }"]; - N74[label="block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"]; - N75[label="block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l}\l"]; - N76[label="block {\l let mut x = 25i;\l let mut y = 25i;\l let mut z = 25i;\l \'a:\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a:\l loop {\l if z == 0i { break ; \"unreachable\"; }\l z -= 1i;\l }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l }\l}\l"]; + N73[label="expr if x > 10is { continue \'a ; \"unreachable\"; }"]; + N74[label="block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"]; + N75[label="block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l}\l"]; + N76[label="block {\l let mut x = 25is;\l let mut y = 25is;\l let mut z = 25is;\l \'a:\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a:\l loop {\l if z == 0is { break ; \"unreachable\"; }\l z -= 1is;\l }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l }\l}\l"]; N0 -> N2; N2 -> N3; N3 -> N4; @@ -90,7 +90,7 @@ digraph block { N13 -> N14; N14 -> N15; N15 -> N16; - N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l}\l"]; + N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l}\l"]; N17 -> N18; N18 -> N19; N19 -> N20; @@ -107,7 +107,7 @@ digraph block { N30 -> N31; N31 -> N32; N32 -> N33; - N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"]; + N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"]; N34 -> N35; N35 -> N36; N36 -> N37; @@ -124,7 +124,7 @@ digraph block { N47 -> N48; N48 -> N49; N49 -> N50; - N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0i { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"]; + N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0is { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"]; N51 -> N52; N52 -> N53; N53 -> N54; @@ -143,7 +143,7 @@ digraph block { N64 -> N65; N65 -> N66; N66 -> N67; - N67 -> N28[label="exiting scope_0 expr continue \'a,\lexiting scope_1 stmt continue \'a ;,\lexiting scope_2 block { continue \'a ; \"unreachable\"; },\lexiting scope_3 expr if x > 10i { continue \'a ; \"unreachable\"; },\lexiting scope_4 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"]; + N67 -> N28[label="exiting scope_0 expr continue \'a,\lexiting scope_1 stmt continue \'a ;,\lexiting scope_2 block { continue \'a ; \"unreachable\"; },\lexiting scope_3 expr if x > 10is { continue \'a ; \"unreachable\"; },\lexiting scope_4 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"]; N68 -> N69; N69 -> N70; N70 -> N71; From e970db37a9bba47bd46ff2755b042f830641e5f1 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Sat, 3 Jan 2015 13:33:54 +1300 Subject: [PATCH 29/49] Remove old slicing hacks and make new slicing work --- src/librustc/middle/expr_use_visitor.rs | 28 +-- src/librustc/middle/lang_items.rs | 2 - src/librustc/middle/mem_categorization.rs | 34 ++-- src/librustc/middle/ty.rs | 5 +- src/librustc_trans/trans/cleanup.rs | 8 +- src/librustc_trans/trans/expr.rs | 35 +--- src/librustc_typeck/check/mod.rs | 215 +++++----------------- src/libsyntax/parse/parser.rs | 115 ++---------- src/libsyntax/parse/token.rs | 98 +++++----- 9 files changed, 137 insertions(+), 403 deletions(-) diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index ca20cbc736dc0..f71d020a1b86f 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -441,28 +441,12 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } ast::ExprIndex(ref lhs, ref rhs) => { // lhs[rhs] - match rhs.node { - ast::ExprRange(ref start, ref end) => { - // Hacked slicing syntax (KILLME). - let args = match (start, end) { - (&Some(ref e1), &Some(ref e2)) => vec![&**e1, &**e2], - (&Some(ref e), &None) => vec![&**e], - (&None, &Some(ref e)) => vec![&**e], - (&None, &None) => Vec::new() - }; - let overloaded = - self.walk_overloaded_operator(expr, &**lhs, args, PassArgs::ByRef); - assert!(overloaded); - } - _ => { - if !self.walk_overloaded_operator(expr, - &**lhs, - vec![&**rhs], - PassArgs::ByRef) { - self.select_from_expr(&**lhs); - self.consume_expr(&**rhs); - } - } + if !self.walk_overloaded_operator(expr, + &**lhs, + vec![&**rhs], + PassArgs::ByRef) { + self.select_from_expr(&**lhs); + self.consume_expr(&**rhs); } } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index bbb11b9f93bbd..2f81d8c0f701e 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -266,8 +266,6 @@ lets_do_this! { ShrTraitLangItem, "shr", shr_trait; IndexTraitLangItem, "index", index_trait; IndexMutTraitLangItem, "index_mut", index_mut_trait; - SliceTraitLangItem, "slice", slice_trait; - SliceMutTraitLangItem, "slice_mut", slice_mut_trait; RangeStructLangItem, "range", range_struct; RangeFromStructLangItem, "range_from", range_from_struct; RangeToStructLangItem, "range_to", range_to_struct; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index af80edb739eb5..99c2fad0e500f 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -482,28 +482,20 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { Ok(self.cat_tup_field(expr, base_cmt, idx.node, expr_ty)) } - ast::ExprIndex(ref base, ref idx) => { - match idx.node { - ast::ExprRange(..) => { - // Slicing syntax special case (KILLME). - Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty)) + ast::ExprIndex(ref base, _) => { + let method_call = ty::MethodCall::expr(expr.id()); + match self.typer.node_method_ty(method_call) { + Some(method_ty) => { + // If this is an index implemented by a method call, then it will + // include an implicit deref of the result. + let ret_ty = ty::ty_fn_ret(method_ty).unwrap(); + self.cat_deref(expr, + self.cat_rvalue_node(expr.id(), + expr.span(), + ret_ty), 1, true) } - _ => { - let method_call = ty::MethodCall::expr(expr.id()); - match self.typer.node_method_ty(method_call) { - Some(method_ty) => { - // If this is an index implemented by a method call, then it will - // include an implicit deref of the result. - let ret_ty = ty::ty_fn_ret(method_ty).unwrap(); - self.cat_deref(expr, - self.cat_rvalue_node(expr.id(), - expr.span(), - ret_ty), 1, true) - } - None => { - self.cat_index(expr, try!(self.cat_expr(&**base))) - } - } + None => { + self.cat_index(expr, self.cat_expr(&**base)) } } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index af35b9e0e8273..d954495055d12 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -1047,7 +1047,7 @@ pub struct ClosureTy<'tcx> { pub abi: abi::Abi, } -#[derive(Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub enum FnOutput<'tcx> { FnConverging(Ty<'tcx>), FnDiverging @@ -1699,8 +1699,7 @@ impl fmt::Show for RegionVid { impl<'tcx> fmt::Show for FnSig<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - // grr, without tcx not much we can do. - write!(f, "(...)") + write!(f, "({}; variadic: {})->{}", self.inputs, self.variadic, self.output) } } diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index ac64e10ecc809..561391400a1c0 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -24,8 +24,7 @@ use trans::common; use trans::common::{Block, FunctionContext, ExprId, NodeInfo}; use trans::debuginfo; use trans::glue; -// Temporary due to slicing syntax hacks (KILLME) -//use middle::region; +use middle::region; use trans::type_::Type; use middle::ty::{self, Ty}; use std::fmt; @@ -129,8 +128,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { // excluding id's that correspond to closure bodies only). For // now we just say that if there is already an AST scope on the stack, // this new AST scope had better be its immediate child. - // Temporarily removed due to slicing syntax hacks (KILLME). - /*let top_scope = self.top_ast_scope(); + let top_scope = self.top_ast_scope(); if top_scope.is_some() { assert_eq!(self.ccx .tcx() @@ -138,7 +136,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { .opt_encl_scope(region::CodeExtent::from_node_id(debug_loc.id)) .map(|s|s.node_id()), top_scope); - }*/ + } self.push_scope(CleanupScope::new(AstScopeKind(debug_loc.id), Some(debug_loc))); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index fe5333061c700..24feb579a0674 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -573,40 +573,7 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, trans_rec_tup_field(bcx, &**base, idx.node) } ast::ExprIndex(ref base, ref idx) => { - match idx.node { - ast::ExprRange(ref start, ref end) => { - // Special case for slicing syntax (KILLME). - let _icx = push_ctxt("trans_slice"); - let ccx = bcx.ccx(); - - let method_call = MethodCall::expr(expr.id); - let method_ty = ccx.tcx() - .method_map - .borrow() - .get(&method_call) - .map(|method| method.ty); - let base_datum = unpack_datum!(bcx, trans(bcx, &**base)); - - let mut args = vec![]; - start.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id))); - end.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id))); - - let result_ty = ty::ty_fn_ret(monomorphize_type(bcx, - method_ty.unwrap())).unwrap(); - let scratch = rvalue_scratch_datum(bcx, result_ty, "trans_slice"); - - unpack_result!(bcx, - trans_overloaded_op(bcx, - expr, - method_call, - base_datum, - args, - Some(SaveIn(scratch.val)), - true)); - DatumBlock::new(bcx, scratch.to_expr_datum()) - } - _ => trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id)) - } + trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id)) } ast::ExprBox(_, ref contents) => { // Special case for `Box` diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 25e53c74f2572..24d2907e953d7 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2377,90 +2377,6 @@ fn autoderef_for_index<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>, } } -/// Checks for a `Slice` (or `SliceMut`) impl at the relevant level of autoderef. If it finds one, -/// installs method info and returns type of method (else None). -fn try_overloaded_slice_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, - method_call: MethodCall, - expr: &ast::Expr, - base_expr: &ast::Expr, - base_ty: Ty<'tcx>, // autoderef'd type - autoderefref: ty::AutoDerefRef<'tcx>, - lvalue_pref: LvaluePreference, - start_expr: &Option>, - end_expr: &Option>) - -> Option<(Ty<'tcx>, /* index type */ - Ty<'tcx>)> /* return type */ -{ - let input_ty = fcx.infcx().next_ty_var(); - let return_ty = fcx.infcx().next_ty_var(); - - let method = match lvalue_pref { - PreferMutLvalue => { - // Try `SliceMut` first, if preferred. - match fcx.tcx().lang_items.slice_mut_trait() { - Some(trait_did) => { - let method_name = match (start_expr, end_expr) { - (&Some(_), &Some(_)) => "slice_or_fail_mut", - (&Some(_), &None) => "slice_from_or_fail_mut", - (&None, &Some(_)) => "slice_to_or_fail_mut", - (&None, &None) => "as_mut_slice_", - }; - - method::lookup_in_trait_adjusted(fcx, - expr.span, - Some(&*base_expr), - token::intern(method_name), - trait_did, - autoderefref, - base_ty, - Some(vec![input_ty, return_ty])) - } - _ => None, - } - } - NoPreference => { - // Otherwise, fall back to `Slice`. - match fcx.tcx().lang_items.slice_trait() { - Some(trait_did) => { - let method_name = match (start_expr, end_expr) { - (&Some(_), &Some(_)) => "slice_or_fail", - (&Some(_), &None) => "slice_from_or_fail", - (&None, &Some(_)) => "slice_to_or_fail", - (&None, &None) => "as_slice_", - }; - - method::lookup_in_trait_adjusted(fcx, - expr.span, - Some(&*base_expr), - token::intern(method_name), - trait_did, - autoderefref, - base_ty, - Some(vec![input_ty, return_ty])) - } - _ => None, - } - } - }; - - // If some lookup succeeded, install method in table - method.map(|method| { - let method_ty = method.ty; - make_overloaded_lvalue_return_type(fcx, Some(method_call), Some(method)); - - let result_ty = ty::ty_fn_ret(method_ty); - let result_ty = match result_ty { - ty::FnConverging(result_ty) => result_ty, - ty::FnDiverging => { - fcx.tcx().sess.span_bug(expr.span, - "slice trait does not define a `!` return") - } - }; - - (input_ty, result_ty) - }) -} - /// To type-check `base_expr[index_expr]`, we progressively autoderef (and otherwise adjust) /// `base_expr`, looking for a type which either supports builtin indexing or overloaded indexing. /// This loop implements one step in that search; the autoderef loop is implemented by @@ -2474,26 +2390,17 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, lvalue_pref: LvaluePreference) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> { + let tcx = fcx.tcx(); debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={})", - expr.repr(fcx.tcx()), - base_expr.repr(fcx.tcx()), - adjusted_ty.repr(fcx.tcx()), + expr.repr(tcx), + base_expr.repr(tcx), + adjusted_ty.repr(tcx), adjustment); - // Try built-in indexing first. - match ty::index(adjusted_ty) { - Some(ty) => { - fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment)); - return Some((fcx.tcx().types.uint, ty)); - } - - None => { } - } - let input_ty = fcx.infcx().next_ty_var(); // Try `IndexMut` first, if preferred. - let method = match (lvalue_pref, fcx.tcx().lang_items.index_mut_trait()) { + let method = match (lvalue_pref, tcx.lang_items.index_mut_trait()) { (PreferMutLvalue, Some(trait_did)) => { method::lookup_in_trait_adjusted(fcx, expr.span, @@ -2508,24 +2415,37 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, }; // Otherwise, fall back to `Index`. - let method = match (method, fcx.tcx().lang_items.index_trait()) { + let method = match (method, tcx.lang_items.index_trait()) { (None, Some(trait_did)) => { method::lookup_in_trait_adjusted(fcx, expr.span, Some(&*base_expr), token::intern("index"), trait_did, - adjustment, + adjustment.clone(), adjusted_ty, Some(vec![input_ty])) } (method, _) => method, }; + if method.is_none() { + // If there are no overridden index impls, use built-in indexing. + match ty::index(adjusted_ty) { + Some(ty) => { + debug!("try_index_step: success, using built-in indexing"); + fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment)); + return Some((tcx.types.uint, ty)); + } + None => {} + } + } + // If some lookup succeeds, write callee into table and extract index/element // type from the method signature. // If some lookup succeeded, install method in table method.and_then(|method| { + debug!("try_index_step: success, using overloaded indexing"); make_overloaded_lvalue_return_type(fcx, Some(method_call), Some(method)). map(|ret| (input_ty, ret.ty)) }) @@ -4270,91 +4190,42 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, if ty::type_is_error(base_t) { fcx.write_ty(id, base_t); } else { - match idx.node { - ast::ExprRange(ref start, ref end) => { - // A slice, rather than an index. Special cased for now (KILLME). + check_expr(fcx, &**idx); + let idx_t = fcx.expr_ty(&**idx); + if ty::type_is_error(idx_t) { + fcx.write_ty(id, idx_t); + } else { let base_t = structurally_resolved_type(fcx, expr.span, base_t); let result = autoderef_for_index(fcx, &**base, base_t, lvalue_pref, |adj_ty, adj| { - try_overloaded_slice_step(fcx, - MethodCall::expr(expr.id), - expr, - &**base, - adj_ty, - adj, - lvalue_pref, - start, - end) + try_index_step(fcx, + MethodCall::expr(expr.id), + expr, + &**base, + adj_ty, + adj, + lvalue_pref) }); - let mut args = vec![]; - start.as_ref().map(|x| args.push(x)); - end.as_ref().map(|x| args.push(x)); - match result { Some((index_ty, element_ty)) => { - for a in args.iter() { - check_expr_has_type(fcx, &***a, index_ty); - } - fcx.write_ty(idx.id, element_ty); - fcx.write_ty(id, element_ty) + check_expr_has_type(fcx, &**idx, index_ty); + fcx.write_ty(id, element_ty); } _ => { - for a in args.iter() { - check_expr(fcx, &***a); - } - fcx.type_error_message(expr.span, - |actual| { - format!("cannot take a slice of a value with type `{}`", + check_expr_has_type(fcx, &**idx, fcx.tcx().types.err); + fcx.type_error_message( + expr.span, + |actual| { + format!("cannot index a value of type `{}`", actual) - }, - base_t, - None); - fcx.write_ty(idx.id, fcx.tcx().types.err); + }, + base_t, + None); fcx.write_ty(id, fcx.tcx().types.err); } } - } - _ => { - check_expr(fcx, &**idx); - let idx_t = fcx.expr_ty(&**idx); - if ty::type_is_error(idx_t) { - fcx.write_ty(id, idx_t); - } else { - let base_t = structurally_resolved_type(fcx, expr.span, base_t); - - let result = - autoderef_for_index(fcx, &**base, base_t, lvalue_pref, |adj_ty, adj| { - try_index_step(fcx, - MethodCall::expr(expr.id), - expr, - &**base, - adj_ty, - adj, - lvalue_pref) - }); - - match result { - Some((index_ty, element_ty)) => { - check_expr_has_type(fcx, &**idx, index_ty); - fcx.write_ty(id, element_ty); - } - _ => { - check_expr_has_type(fcx, &**idx, fcx.tcx().types.err); - fcx.type_error_message( - expr.span, - |actual| { - format!("cannot index a value of type `{}`", - actual) - }, - base_t, - None); - fcx.write_ty(id, fcx.tcx().types.err); - } - } - } - } } } } @@ -4387,7 +4258,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, }; // Note that we don't check the type of start/end satisfy any - // bounds because right the range structs do not have any. If we add + // bounds because right now the range structs do not have any. If we add // some bounds, then we'll need to check `t_start` against them here. let range_type = match idx_type { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index f35f42d5aca30..7824dacd3a164 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -63,7 +63,7 @@ use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple}; use ast::{Visibility, WhereClause}; use ast; use ast_util::{self, as_prec, ident_to_path, operator_prec}; -use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, DUMMY_SP}; +use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp}; use diagnostic; use ext::tt::macro_parser; use parse; @@ -2103,22 +2103,6 @@ impl<'a> Parser<'a> { ExprIndex(expr, idx) } - pub fn mk_slice(&mut self, - expr: P, - start: Option>, - end: Option>, - _mutbl: Mutability) - -> ast::Expr_ { - // FIXME: we could give more accurate span info here. - let (lo, hi) = match (&start, &end) { - (&Some(ref s), &Some(ref e)) => (s.span.lo, e.span.hi), - (&Some(ref s), &None) => (s.span.lo, s.span.hi), - (&None, &Some(ref e)) => (e.span.lo, e.span.hi), - (&None, &None) => (DUMMY_SP.lo, DUMMY_SP.hi), - }; - ExprIndex(expr, self.mk_expr(lo, hi, ExprRange(start, end))) - } - pub fn mk_range(&mut self, start: Option>, end: Option>) @@ -2550,87 +2534,28 @@ impl<'a> Parser<'a> { } // expr[...] - // Could be either an index expression or a slicing expression. - // Any slicing non-terminal can have a mutable version with `mut` - // after the opening square bracket. + // An index expression. token::OpenDelim(token::Bracket) => { + let bracket_pos = self.span.lo; self.bump(); - let mutbl = if self.eat_keyword(keywords::Mut) { - MutMutable + if self.eat(&token::CloseDelim(token::Bracket)) { + // No expression, expand to a FullRange + let ix = { + hi = self.last_span.hi; + let range = ExprStruct(ident_to_path(mk_sp(lo, hi), + token::special_idents::FullRange), + vec![], + None); + self.mk_expr(bracket_pos, hi, range) + }; + let index = self.mk_index(e, ix); + e = self.mk_expr(lo, hi, index) } else { - MutImmutable - }; - match self.token { - // e.index(&FullRange) - token::CloseDelim(token::Bracket) => { - self.bump(); - hi = self.span.hi; - let slice = self.mk_slice(e, None, None, mutbl); - e = self.mk_expr(lo, hi, slice) - } - // e.index(&(0..e)) - token::DotDot => { - self.bump(); - match self.token { - // e.index(&(..)) - token::CloseDelim(token::Bracket) => { - self.bump(); - hi = self.span.hi; - let slice = self.mk_slice(e, None, None, mutbl); - e = self.mk_expr(lo, hi, slice); - - self.span_err(e.span, "incorrect slicing expression: `[..]`"); - self.span_note(e.span, - "use `expr.index(&FullRange)` to construct a slice of the whole of expr"); - } - // e.index(&(0..e)) - _ => { - hi = self.span.hi; - let e2 = self.parse_expr(); - self.commit_expr_expecting(&*e2, token::CloseDelim(token::Bracket)); - let slice = self.mk_slice(e, None, Some(e2), mutbl); - e = self.mk_expr(lo, hi, slice) - } - } - } - // e[e] | e.index(&(e..)) | e.index(&(e..e)) - _ => { - let ix = self.parse_expr_res(RESTRICTION_NO_DOTS); - match self.token { - // e.index(&(e..)) | e.index(&(e..e)) - token::DotDot => { - self.bump(); - let e2 = match self.token { - // e.index(&(e..)) - token::CloseDelim(token::Bracket) => { - self.bump(); - None - } - // e.index(&(e..e)) - _ => { - let e2 = self.parse_expr_res(RESTRICTION_NO_DOTS); - self.commit_expr_expecting(&*e2, - token::CloseDelim(token::Bracket)); - Some(e2) - } - }; - hi = self.span.hi; - let slice = self.mk_slice(e, Some(ix), e2, mutbl); - e = self.mk_expr(lo, hi, slice) - } - // e[e] - _ => { - if mutbl == ast::MutMutable { - self.span_err(e.span, - "`mut` keyword is invalid in index expressions"); - } - hi = self.span.hi; - self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket)); - let index = self.mk_index(e, ix); - e = self.mk_expr(lo, hi, index) - } - } - } + let ix = self.parse_expr(); + hi = self.span.hi; + self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket)); + let index = self.mk_index(e, ix); + e = self.mk_expr(lo, hi, index) } } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index ca683a5647246..ada463a40cbc2 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -515,66 +515,66 @@ declare_special_idents_and_keywords! { (9, unnamed_field, ""); (10, type_self, "Self"); (11, prelude_import, "prelude_import"); + (12, FullRange, "FullRange"); } pub mod keywords { // These ones are variants of the Keyword enum 'strict: - (12, As, "as"); - (13, Break, "break"); - (14, Crate, "crate"); - (15, Else, "else"); - (16, Enum, "enum"); - (17, Extern, "extern"); - (18, False, "false"); - (19, Fn, "fn"); - (20, For, "for"); - (21, If, "if"); - (22, Impl, "impl"); - (23, In, "in"); - (24, Let, "let"); - (25, Loop, "loop"); - (26, Match, "match"); - (27, Mod, "mod"); - (28, Move, "move"); - (29, Mut, "mut"); - (30, Pub, "pub"); - (31, Ref, "ref"); - (32, Return, "return"); + (13, As, "as"); + (14, Break, "break"); + (15, Crate, "crate"); + (16, Else, "else"); + (17, Enum, "enum"); + (18, Extern, "extern"); + (19, False, "false"); + (20, Fn, "fn"); + (21, For, "for"); + (22, If, "if"); + (23, Impl, "impl"); + (24, In, "in"); + (25, Let, "let"); + (26, Loop, "loop"); + (27, Match, "match"); + (28, Mod, "mod"); + (29, Move, "move"); + (30, Mut, "mut"); + (31, Pub, "pub"); + (32, Ref, "ref"); + (33, Return, "return"); // Static and Self are also special idents (prefill de-dupes) (super::STATIC_KEYWORD_NAME_NUM, Static, "static"); (super::SELF_KEYWORD_NAME_NUM, Self, "self"); - (33, Struct, "struct"); + (34, Struct, "struct"); (super::SUPER_KEYWORD_NAME_NUM, Super, "super"); - (34, True, "true"); - (35, Trait, "trait"); - (36, Type, "type"); - (37, Unsafe, "unsafe"); - (38, Use, "use"); - (39, Virtual, "virtual"); - (40, While, "while"); - (41, Continue, "continue"); - (42, Proc, "proc"); - (43, Box, "box"); - (44, Const, "const"); - (45, Where, "where"); - + (35, True, "true"); + (36, Trait, "trait"); + (37, Type, "type"); + (38, Unsafe, "unsafe"); + (39, Use, "use"); + (40, Virtual, "virtual"); + (41, While, "while"); + (42, Continue, "continue"); + (43, Proc, "proc"); + (44, Box, "box"); + (45, Const, "const"); + (46, Where, "where"); 'reserved: - (46, Alignof, "alignof"); - (47, Be, "be"); - (48, Offsetof, "offsetof"); - (49, Priv, "priv"); - (50, Pure, "pure"); - (51, Sizeof, "sizeof"); - (52, Typeof, "typeof"); - (53, Unsized, "unsized"); - (54, Yield, "yield"); - (55, Do, "do"); - (56, Abstract, "abstract"); - (57, Final, "final"); - (58, Override, "override"); - (59, Macro, "macro"); + (47, Alignof, "alignof"); + (48, Be, "be"); + (49, Offsetof, "offsetof"); + (50, Priv, "priv"); + (51, Pure, "pure"); + (52, Sizeof, "sizeof"); + (53, Typeof, "typeof"); + (54, Unsized, "unsized"); + (55, Yield, "yield"); + (56, Do, "do"); + (57, Abstract, "abstract"); + (58, Final, "final"); + (59, Override, "override"); + (60, Macro, "macro"); } } From 77ed4974569fbe71c0ba76327b5e2a34a515ed73 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Sat, 3 Jan 2015 13:34:13 +1300 Subject: [PATCH 30/49] Tests --- src/test/bench/shootout-fasta-redux.rs | 4 +-- src/test/bench/shootout-k-nucleotide.rs | 4 +-- .../borrowck-array-double-move.rs | 2 +- .../borrowck-vec-pattern-move-tail.rs | 2 +- .../packed-struct-generic-transmute.rs | 2 +- src/test/compile-fail/slice-1.rs | 6 ++-- src/test/compile-fail/slice-2.rs | 8 ++--- src/test/compile-fail/slice-borrow.rs | 2 +- src/test/compile-fail/slice-mut-2.rs | 2 +- src/test/compile-fail/slice-mut.rs | 2 +- src/test/debuginfo/vec-slices.rs | 2 +- src/test/run-pass/auto-encode.rs | 2 +- .../run-pass/deriving-encodable-decodable.rs | 2 +- src/test/run-pass/issue-8898.rs | 8 ++--- src/test/run-pass/repeated-vector-syntax.rs | 4 +-- src/test/run-pass/slice-2.rs | 32 +++++++++---------- src/test/run-pass/slice.rs | 19 +++++------ 17 files changed, 52 insertions(+), 51 deletions(-) diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 7109dc7948ed5..9a6152dc13c9d 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -130,7 +130,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { copy_memory(buf.as_mut_slice(), alu); let buf_len = buf.len(); copy_memory(buf.slice_mut(alu_len, buf_len), - alu.index(&(0..LINE_LEN))); + &alu[0..LINE_LEN]); let mut pos = 0; let mut bytes; @@ -206,7 +206,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> { for i in range(0u, chars_left) { buf[i] = self.nextc(); } - self.out.write(buf.index(&(0..chars_left))) + self.out.write(&buf[0..chars_left]) } } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 65127868b8788..4f71ea8cbe997 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -247,14 +247,14 @@ fn generate_frequencies(mut input: &[u8], frame: uint) -> Table { // Pull first frame. for _ in range(0, frame) { code = code.push_char(input[0]); - input = input.index(&(1..)); + input = &input[1..]; } frequencies.lookup(code, BumpCallback); while input.len() != 0 && input[0] != ('>' as u8) { code = code.rotate(input[0], frame); frequencies.lookup(code, BumpCallback); - input = input.index(&(1..)); + input = &input[1..]; } frequencies } diff --git a/src/test/compile-fail/borrowck-array-double-move.rs b/src/test/compile-fail/borrowck-array-double-move.rs index 79a6dd005a7ac..c872d0dc4b9c4 100644 --- a/src/test/compile-fail/borrowck-array-double-move.rs +++ b/src/test/compile-fail/borrowck-array-double-move.rs @@ -12,7 +12,7 @@ fn f() { let mut a = [box 0i, box 1i]; drop(a[0]); a[1] = box 2i; - drop(a[0]); //~ ERROR use of moved value: `a.index(&(..))` + drop(a[0]); //~ ERROR use of moved value: `a[..]` } fn main() { diff --git a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs index b328ea722a09a..cb8762f44fb79 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs @@ -14,6 +14,6 @@ fn main() { [1, 2, tail..] => tail, _ => unreachable!() }; - a[0] = 0; //~ ERROR cannot assign to `a.index(&(..))` because it is borrowed + a[0] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed t[0]; } diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs index 0d8631788a9e1..38177d076455d 100644 --- a/src/test/compile-fail/packed-struct-generic-transmute.rs +++ b/src/test/compile-fail/packed-struct-generic-transmute.rs @@ -34,6 +34,6 @@ fn main() { let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 }; unsafe { let oof: Oof<[u8; 5], i32> = mem::transmute(foo); - println!("{} {}", oof.rab.index(&FullRange), oof.zab); + println!("{} {}", &oof.rab[], oof.zab); } } diff --git a/src/test/compile-fail/slice-1.rs b/src/test/compile-fail/slice-1.rs index 26281c2e90754..903760caf1a1e 100644 --- a/src/test/compile-fail/slice-1.rs +++ b/src/test/compile-fail/slice-1.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test slicing expr.index(&(..)) is an error and gives a helpful error message. +// Test slicing expr[..] is an error and gives a helpful error message. struct Foo; fn main() { let x = Foo; - x.index(&(..)); //~ ERROR incorrect slicing expression: `[..]` - //~^ NOTE use `expr.index(&FullRange)` to construct a slice of the whole of expr + &x[..]; //~ ERROR incorrect slicing expression: `[..]` + //~^ NOTE use `&expr[]` to construct a slice of the whole of expr } diff --git a/src/test/compile-fail/slice-2.rs b/src/test/compile-fail/slice-2.rs index 1e850d6307eb4..9ee700225456b 100644 --- a/src/test/compile-fail/slice-2.rs +++ b/src/test/compile-fail/slice-2.rs @@ -16,8 +16,8 @@ struct Foo; fn main() { let x = Foo; - x.index(&FullRange); //~ ERROR cannot take a slice of a value with type `Foo` - x.index(&(Foo..)); //~ ERROR cannot take a slice of a value with type `Foo` - x.index(&(0..Foo)); //~ ERROR cannot take a slice of a value with type `Foo` - x.index(&(Foo..Foo)); //~ ERROR cannot take a slice of a value with type `Foo` + &x[]; //~ ERROR cannot take a slice of a value with type `Foo` + &x[Foo..]; //~ ERROR cannot take a slice of a value with type `Foo` + &x[0..Foo]; //~ ERROR cannot take a slice of a value with type `Foo` + &x[Foo..Foo]; //~ ERROR cannot take a slice of a value with type `Foo` } diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs index 7839013ee2224..aab187f97515a 100644 --- a/src/test/compile-fail/slice-borrow.rs +++ b/src/test/compile-fail/slice-borrow.rs @@ -16,6 +16,6 @@ fn main() { let y; { let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough - y = x.index(&(1..)); + y = &x[1..]; } } diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs index b7d7ea67f067c..b34c9a49268b5 100644 --- a/src/test/compile-fail/slice-mut-2.rs +++ b/src/test/compile-fail/slice-mut-2.rs @@ -16,5 +16,5 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Can't mutably slice an immutable slice let slice: &mut [int] = &mut [0, 1]; - x.index(&(2..4)) = slice; //~ ERROR cannot borrow + &mut x[2..4] = slice; //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs index 3d621580f5d4a..e7353dfbcd0e4 100644 --- a/src/test/compile-fail/slice-mut.rs +++ b/src/test/compile-fail/slice-mut.rs @@ -15,5 +15,5 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; // Immutable slices are not mutable. - let y: &mut[_] = x.index(&(2..4)); //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl + let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl } diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs index f2cb5f82a6c4c..14f1dbb9d651c 100644 --- a/src/test/debuginfo/vec-slices.rs +++ b/src/test/debuginfo/vec-slices.rs @@ -93,7 +93,7 @@ fn main() { let empty: &[i64] = &[]; let singleton: &[i64] = &[1]; let multiple: &[i64] = &[2, 3, 4, 5]; - let slice_of_slice = multiple.index(&(1..3)); + let slice_of_slice = &multiple[1..3]; let padded_tuple: &[(i32, i16)] = &[(6, 7), (8, 9)]; diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 6eb4bc352d194..9b030de998373 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -35,7 +35,7 @@ fn test_rbml<'a, 'b, A: let mut rbml_w = EBwriter::Encoder::new(&mut wr); a1.encode(&mut rbml_w); - let d: serialize::rbml::Doc<'a> = EBDoc::new(wr.index(&FullRange)); + let d: serialize::rbml::Doc<'a> = EBDoc::new(&wr[]); let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d); let a2: A = Decodable::decode(&mut decoder); assert!(*a1 == a2); diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index 459060d349ce4..01814e8eab790 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -59,7 +59,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable> + let mut w = Vec::new(); let mut e = Encoder::new(&mut w); obj.encode(&mut e); - let doc = rbml::Doc::new(@w.index(&FullRange)); + let doc = rbml::Doc::new(&w[]); let mut dec = Decoder::new(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs index 706f640c18d95..5b90878aa2854 100644 --- a/src/test/run-pass/issue-8898.rs +++ b/src/test/run-pass/issue-8898.rs @@ -20,9 +20,9 @@ pub fn main() { let x = [(), ()]; let slice = x.index(&(0..1)); - assert_repr_eq(abc.index(&FullRange), "[1, 2, 3]".to_string()); - assert_repr_eq(tf.index(&FullRange), "[true, false]".to_string()); - assert_repr_eq(x.index(&FullRange), "[(), ()]".to_string()); + assert_repr_eq(&abc[], "[1, 2, 3]".to_string()); + assert_repr_eq(&tf[], "[true, false]".to_string()); + assert_repr_eq(&x[], "[(), ()]".to_string()); assert_repr_eq(slice, "[()]".to_string()); - assert_repr_eq(x.index(&FullRange), "[(), ()]".to_string()); + assert_repr_eq(&x[], "[(), ()]".to_string()); } diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs index e5a617634632f..e854a7326329c 100644 --- a/src/test/run-pass/repeated-vector-syntax.rs +++ b/src/test/run-pass/repeated-vector-syntax.rs @@ -16,8 +16,8 @@ pub fn main() { print!("["); for xi in x.iter() { - print!("{}, ", (*xi)[]); + print!("{}, ", &xi[]); } println!("]"); - println!("{}", y.index(&FullRange)); + println!("{}", &y[]); } diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs index 7be05b9d71e53..05f318b53c2e5 100644 --- a/src/test/run-pass/slice-2.rs +++ b/src/test/run-pass/slice-2.rs @@ -15,57 +15,57 @@ fn main() { let x: &[int] = &[1, 2, 3, 4, 5]; let cmp: &[int] = &[1, 2, 3, 4, 5]; - assert!(x.index(&FullRange) == cmp); + assert!(&x[] == cmp); let cmp: &[int] = &[3, 4, 5]; - assert!(x.index(&(2..)) == cmp); + assert!(&x[2..] == cmp); let cmp: &[int] = &[1, 2, 3]; - assert!(x.index(&(0..3)) == cmp); + assert!(&x[0..3] == cmp); let cmp: &[int] = &[2, 3, 4]; - assert!(x.index(&(1..4)) == cmp); + assert!(&x[1..4] == cmp); let x: Vec = vec![1, 2, 3, 4, 5]; let cmp: &[int] = &[1, 2, 3, 4, 5]; - assert!(x.index(&FullRange) == cmp); + assert!(&x[] == cmp); let cmp: &[int] = &[3, 4, 5]; - assert!(x.index(&(2..)) == cmp); + assert!(&x[2..] == cmp); let cmp: &[int] = &[1, 2, 3]; - assert!(x.index(&(0..3)) == cmp); + assert!(&x[0..3] == cmp); let cmp: &[int] = &[2, 3, 4]; - assert!(x.index(&(1..4)) == cmp); + assert!(&x[1..4] == cmp); let x: &mut [int] = &mut [1, 2, 3, 4, 5]; { let cmp: &mut [int] = &mut [1, 2, 3, 4, 5]; - assert!(x[mut] == cmp); + assert!(&mut x[] == cmp); } { let cmp: &mut [int] = &mut [3, 4, 5]; - assert!(x[mut 2..] == cmp); + assert!(&mut x[2..] == cmp); } { let cmp: &mut [int] = &mut [1, 2, 3]; - assert!(x[mut ..3] == cmp); + assert!(&mut x[..3] == cmp); } { let cmp: &mut [int] = &mut [2, 3, 4]; - assert!(x[mut 1..4] == cmp); + assert!(&mut x[1..4] == cmp); } let mut x: Vec = vec![1, 2, 3, 4, 5]; { let cmp: &mut [int] = &mut [1, 2, 3, 4, 5]; - assert!(x[mut] == cmp); + assert!(&mut x[] == cmp); } { let cmp: &mut [int] = &mut [3, 4, 5]; - assert!(x[mut 2..] == cmp); + assert!(&mut x[2..] == cmp); } { let cmp: &mut [int] = &mut [1, 2, 3]; - assert!(x[mut ..3] == cmp); + assert!(&mut x[..3] == cmp); } { let cmp: &mut [int] = &mut [2, 3, 4]; - assert!(x[mut 1..4] == cmp); + assert!(&mut x[1..4] == cmp); } } diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs index c6dfc8dfd23a3..e039886022c27 100644 --- a/src/test/run-pass/slice.rs +++ b/src/test/run-pass/slice.rs @@ -13,7 +13,7 @@ #![feature(slicing_syntax)] extern crate core; -use core::ops::{Slice,SliceMut}; +use core::ops::{Index, Range, RangeTo, RangeFrom, FullRange}; static mut COUNT: uint = 0; @@ -56,16 +56,17 @@ impl SliceMut for Foo { self } } + fn main() { let mut x = Foo; - x.index(&FullRange); - x.index(&(Foo..)); - x.index(&(0..Foo)); - x.index(&(Foo..Foo)); - x[mut]; - x[mut Foo..]; - x[mut ..Foo]; - x[mut Foo..Foo]; + &x[]; + &x[Foo..]; + &x[0..Foo]; + &x[Foo..Foo]; + &mut x[]; + &mut x[Foo..]; + &mut x[..Foo]; + &mut x[Foo..Foo]; unsafe { assert!(COUNT == 8); } From 480374a696a4d23d27ade99ac8280c16b5b01e85 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Sun, 4 Jan 2015 16:08:18 +1300 Subject: [PATCH 31/49] Only use built-in indexing for uint indexes --- src/librustc/middle/check_const.rs | 1 - src/librustc_typeck/check/method/confirm.rs | 7 +++-- src/librustc_typeck/check/mod.rs | 35 +++++++++++---------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index ac53bdbefcf10..d8d7c5afb1066 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -165,7 +165,6 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) { ast::ExprParen(..) | ast::ExprField(..) | ast::ExprTupField(..) | - ast::ExprIndex(..) | ast::ExprTup(..) | ast::ExprRepeat(..) | ast::ExprStruct(..) => {} diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index a9018c8985a2f..d43850989fe79 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -562,7 +562,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { self.fcx.adjust_expr_ty( &**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), @@ -570,10 +571,10 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { &**base_expr, adjusted_base_ty, base_adjustment, - PreferMutLvalue); + PreferMutLvalue, + index_expr_ty); if let Some((input_ty, return_ty)) = result { - let index_expr_ty = self.fcx.expr_ty(&**index_expr); demand::suptype(self.fcx, index_expr.span, input_ty, index_expr_ty); let expr_ty = self.fcx.expr_ty(&**expr); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 24d2907e953d7..50f73312c770b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2387,18 +2387,30 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, base_expr: &ast::Expr, adjusted_ty: Ty<'tcx>, adjustment: ty::AutoDerefRef<'tcx>, - lvalue_pref: LvaluePreference) + lvalue_pref: LvaluePreference, + index_ty: Ty<'tcx>) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> { let tcx = fcx.tcx(); - debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={})", + debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={}, index_ty={})", expr.repr(tcx), base_expr.repr(tcx), adjusted_ty.repr(tcx), - adjustment); + adjustment, + index_ty.repr(tcx)); let input_ty = fcx.infcx().next_ty_var(); + // First, try built-in indexing. + match (ty::index(adjusted_ty), &index_ty.sty) { + (Some(ty), &ty::ty_uint(ast::TyU)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => { + debug!("try_index_step: success, using built-in indexing"); + fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment)); + return Some((tcx.types.uint, ty)); + } + _ => {} + } + // Try `IndexMut` first, if preferred. let method = match (lvalue_pref, tcx.lang_items.index_mut_trait()) { (PreferMutLvalue, Some(trait_did)) => { @@ -2429,18 +2441,6 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, (method, _) => method, }; - if method.is_none() { - // If there are no overridden index impls, use built-in indexing. - match ty::index(adjusted_ty) { - Some(ty) => { - debug!("try_index_step: success, using built-in indexing"); - fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment)); - return Some((tcx.types.uint, ty)); - } - None => {} - } - } - // If some lookup succeeds, write callee into table and extract index/element // type from the method signature. // If some lookup succeeded, install method in table @@ -4205,11 +4205,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, &**base, adj_ty, adj, - lvalue_pref) + lvalue_pref, + idx_t) }); match result { Some((index_ty, element_ty)) => { + // FIXME: we've already checked idx above, we should + // probably just demand subtype or something here. check_expr_has_type(fcx, &**idx, index_ty); fcx.write_ty(id, element_ty); } From 791f5456859845a4a1814eca45aa900fc62d4e44 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Mon, 5 Jan 2015 12:02:47 +1300 Subject: [PATCH 32/49] Pretty print empty structs properly --- src/libsyntax/print/pprust.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 9a38f6c8ac325..721769be7a461 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1537,6 +1537,9 @@ impl<'a> State<'a> { ast::ExprStruct(ref path, ref fields, ref wth) => { try!(self.print_path(path, true)); + if fields.is_empty() && wth.is_none() { + return; + } try!(word(&mut self.s, "{")); try!(self.commasep_cmnt( Consistent, @@ -1560,7 +1563,7 @@ impl<'a> State<'a> { try!(self.print_expr(&**expr)); try!(self.end()); } - _ => try!(word(&mut self.s, ",")) + _ => try!(word(&mut self.s, ",")), } try!(word(&mut self.s, "}")); } From 240423236906a2df976edd6065bbc595711b83c0 Mon Sep 17 00:00:00 2001 From: Jonathan Reem Date: Tue, 6 Jan 2015 22:59:07 +0100 Subject: [PATCH 33/49] Remove the unneeded Sized bound on TypeId creation This bound is probably unintentional and is unnecessarily constricting. --- src/libcore/intrinsics.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 7e1359d5c1201..fe9100e8a5cc6 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -200,8 +200,7 @@ extern "rust-intrinsic" { /// Gets an identifier which is globally unique to the specified type. This /// function will return the same value for a type regardless of whichever /// crate it is invoked in. - pub fn type_id() -> TypeId; - + pub fn type_id() -> TypeId; /// Create a value initialized to zero. /// @@ -552,8 +551,9 @@ pub struct TypeId { impl TypeId { /// Returns the `TypeId` of the type this generic function has been instantiated with - pub fn of() -> TypeId { + pub fn of() -> TypeId { unsafe { type_id::() } } + pub fn hash(&self) -> u64 { self.t } } From 3ed7f067dc0319cd9e7bb6a8253ba031d0bdf1f3 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 5 Jan 2015 14:01:31 -0500 Subject: [PATCH 34/49] Fix fallout in libs. For the most part I just tagged impls as `#[old_impl_check]`. --- src/libcollections/btree/node.rs | 3 ++- src/libcollections/lib.rs | 1 + src/librustc/lib.rs | 1 + src/librustc/util/ppaux.rs | 1 + src/libserialize/collection_impls.rs | 4 ++++ src/libserialize/lib.rs | 1 + src/libstd/collections/hash/map.rs | 10 ++++++++++ src/libstd/collections/hash/set.rs | 15 +++++++++++++++ src/libstd/io/mod.rs | 1 + src/libstd/lib.rs | 1 + src/libsyntax/ast.rs | 4 ++-- 11 files changed, 39 insertions(+), 3 deletions(-) diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 0a93bbf89c997..1c646032bf15a 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -1417,7 +1417,7 @@ pub type MutTraversal<'a, K, V> = AbsTraversal = AbsTraversal>; - +#[old_impl_check] impl> Iterator for AbsTraversal { type Item = TraversalItem; @@ -1433,6 +1433,7 @@ impl> Iterator for AbsTraversal { } } +#[old_impl_check] impl> DoubleEndedIterator for AbsTraversal { fn next_back(&mut self) -> Option> { let tail_is_edge = self.tail_is_edge; diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 5bf5f78af94c2..00d3e795f7432 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -26,6 +26,7 @@ #![feature(unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] #![feature(old_orphan_check)] +#![feature(old_impl_check)] #![feature(associated_types)] #![no_std] diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 3ed712b15dfdc..d22e3208bbef7 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -28,6 +28,7 @@ #![feature(rustc_diagnostic_macros)] #![feature(unboxed_closures)] #![feature(old_orphan_check)] +#![feature(old_impl_check)] #![feature(associated_types)] extern crate arena; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 8c2a9993004d9..e5e425c9c2699 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -1349,6 +1349,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for ty::Binder { } } +#[old_impl_check] impl<'tcx, S, H, K, V> Repr<'tcx> for HashMap where K : Hash + Eq + Repr<'tcx>, V : Repr<'tcx>, diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index 7ba329c518e91..d89a4754d2efe 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -156,6 +156,7 @@ impl< } } +#[old_impl_check] impl< K: Encodable + Hash + Eq, V: Encodable, @@ -175,6 +176,7 @@ impl< } } +#[old_impl_check] impl< K: Decodable + Hash + Eq, V: Decodable, @@ -195,6 +197,7 @@ impl< } } +#[old_impl_check] impl< T: Encodable + Hash + Eq, X, @@ -212,6 +215,7 @@ impl< } } +#[old_impl_check] impl< T: Decodable + Hash + Eq, S, diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 8fe15f00ded73..ee94095bd158f 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -26,6 +26,7 @@ Core encoding and decoding interfaces. #![feature(macro_rules, default_type_params, phase, slicing_syntax, globs)] #![feature(unboxed_closures)] #![feature(associated_types)] +#![feature(old_impl_check)] // test harness access #[cfg(test)] diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index a3fc38c34e84f..5372c51f95fff 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -439,6 +439,7 @@ impl SearchResult { } } +#[old_impl_check] impl, V, S, H: Hasher> HashMap { fn make_hash>(&self, x: &X) -> SafeHash { table::make_hash(&self.hasher, x) @@ -517,6 +518,7 @@ impl HashMap { } } +#[old_impl_check] impl, V, S, H: Hasher> HashMap { /// Creates an empty hashmap which will use the given hasher to hash keys. /// @@ -1191,6 +1193,7 @@ fn search_entry_hashed<'a, K, V, Q: ?Sized>(table: &'a mut RawTable, hash: } #[stable] +#[old_impl_check] impl, V: PartialEq, S, H: Hasher> PartialEq for HashMap { fn eq(&self, other: &HashMap) -> bool { if self.len() != other.len() { return false; } @@ -1202,9 +1205,11 @@ impl, V: PartialEq, S, H: Hasher> PartialEq for HashMap, V: Eq, S, H: Hasher> Eq for HashMap {} #[stable] +#[old_impl_check] impl + Show, V: Show, S, H: Hasher> Show for HashMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); @@ -1219,6 +1224,7 @@ impl + Show, V: Show, S, H: Hasher> Show for HashMap } #[stable] +#[old_impl_check] impl, V, S, H: Hasher + Default> Default for HashMap { #[stable] fn default() -> HashMap { @@ -1227,6 +1233,7 @@ impl, V, S, H: Hasher + Default> Default for HashMap } #[stable] +#[old_impl_check] impl + Eq, Q: ?Sized, V, S, H: Hasher> Index for HashMap where Q: BorrowFrom + Hash + Eq { @@ -1239,6 +1246,7 @@ impl + Eq, Q: ?Sized, V, S, H: Hasher> Index for HashMap + Eq, Q: ?Sized, V, S, H: Hasher> IndexMut for HashMap where Q: BorrowFrom + Hash + Eq { @@ -1472,6 +1480,7 @@ impl<'a, Q: ?Sized + 'a + ToOwned, K: 'a, V: 'a> VacantEntry<'a, Q, K, V> { } #[stable] +#[old_impl_check] impl, V, S, H: Hasher + Default> FromIterator<(K, V)> for HashMap { fn from_iter>(iter: T) -> HashMap { let lower = iter.size_hint().0; @@ -1482,6 +1491,7 @@ impl, V, S, H: Hasher + Default> FromIterator<(K, V)> for Has } #[stable] +#[old_impl_check] impl, V, S, H: Hasher> Extend<(K, V)> for HashMap { fn extend>(&mut self, mut iter: T) { for (k, v) in iter { diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 211bfe2c10e8f..1b3d401fb8435 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -128,6 +128,7 @@ impl HashSet { } } +#[old_impl_check] impl, S, H: Hasher> HashSet { /// Creates a new empty hash set which will use the given hasher to hash /// keys. @@ -571,6 +572,7 @@ impl, S, H: Hasher> HashSet { } #[stable] +#[old_impl_check] impl, S, H: Hasher> PartialEq for HashSet { fn eq(&self, other: &HashSet) -> bool { if self.len() != other.len() { return false; } @@ -580,9 +582,11 @@ impl, S, H: Hasher> PartialEq for HashSet { } #[stable] +#[old_impl_check] impl, S, H: Hasher> Eq for HashSet {} #[stable] +#[old_impl_check] impl + fmt::Show, S, H: Hasher> fmt::Show for HashSet { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); @@ -597,6 +601,7 @@ impl + fmt::Show, S, H: Hasher> fmt::Show for HashSet { } #[stable] +#[old_impl_check] impl, S, H: Hasher + Default> FromIterator for HashSet { fn from_iter>(iter: I) -> HashSet { let lower = iter.size_hint().0; @@ -607,6 +612,7 @@ impl, S, H: Hasher + Default> FromIterator for HashSet, S, H: Hasher> Extend for HashSet { fn extend>(&mut self, mut iter: I) { for k in iter { @@ -616,6 +622,7 @@ impl, S, H: Hasher> Extend for HashSet { } #[stable] +#[old_impl_check] impl, S, H: Hasher + Default> Default for HashSet { #[stable] fn default() -> HashSet { @@ -624,6 +631,7 @@ impl, S, H: Hasher + Default> Default for HashSet { } #[stable] +#[old_impl_check] impl<'a, 'b, T: Eq + Hash + Clone, S, H: Hasher + Default> BitOr<&'b HashSet> for &'a HashSet { type Output = HashSet; @@ -654,6 +662,7 @@ BitOr<&'b HashSet> for &'a HashSet { } #[stable] +#[old_impl_check] impl<'a, 'b, T: Eq + Hash + Clone, S, H: Hasher + Default> BitAnd<&'b HashSet> for &'a HashSet { type Output = HashSet; @@ -684,6 +693,7 @@ BitAnd<&'b HashSet> for &'a HashSet { } #[stable] +#[old_impl_check] impl<'a, 'b, T: Eq + Hash + Clone, S, H: Hasher + Default> BitXor<&'b HashSet> for &'a HashSet { type Output = HashSet; @@ -714,6 +724,7 @@ BitXor<&'b HashSet> for &'a HashSet { } #[stable] +#[old_impl_check] impl<'a, 'b, T: Eq + Hash + Clone, S, H: Hasher + Default> Sub<&'b HashSet> for &'a HashSet { type Output = HashSet; @@ -816,6 +827,7 @@ impl<'a, K: 'a> Iterator for Drain<'a, K> { } #[stable] +#[old_impl_check] impl<'a, T, S, H> Iterator for Intersection<'a, T, H> where T: Eq + Hash, H: Hasher { @@ -839,6 +851,7 @@ impl<'a, T, S, H> Iterator for Intersection<'a, T, H> } #[stable] +#[old_impl_check] impl<'a, T, S, H> Iterator for Difference<'a, T, H> where T: Eq + Hash, H: Hasher { @@ -862,6 +875,7 @@ impl<'a, T, S, H> Iterator for Difference<'a, T, H> } #[stable] +#[old_impl_check] impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H> where T: Eq + Hash, H: Hasher { @@ -872,6 +886,7 @@ impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H> } #[stable] +#[old_impl_check] impl<'a, T, S, H> Iterator for Union<'a, T, H> where T: Eq + Hash, H: Hasher { diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 5bef473db990c..61ed387dd07eb 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -1604,6 +1604,7 @@ pub struct IncomingConnections<'a, A: ?Sized +'a> { inc: &'a mut A, } +#[old_impl_check] impl<'a, T, A: ?Sized + Acceptor> Iterator for IncomingConnections<'a, A> { type Item = IoResult; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b9f226c5aca73..592163e0e8c6b 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -108,6 +108,7 @@ #![feature(default_type_params, phase, lang_items, unsafe_destructor)] #![feature(slicing_syntax, unboxed_closures)] #![feature(old_orphan_check)] +#![feature(old_impl_check)] #![feature(associated_types)] // Don't link to std. We are std. diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7aa7c4fcfb301..0054cb9509ac6 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -982,8 +982,8 @@ pub enum Sign { Plus } -impl Sign where T: Int { - pub fn new(n: T) -> Sign { +impl Sign { + pub fn new(n: T) -> Sign { if n < Int::zero() { Minus } else { From 2375a79152b8a6554c3e97a3f127fedd75f7495f Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 5 Jan 2015 06:17:42 -0500 Subject: [PATCH 35/49] Implement impl reachability rules. This is a [breaking-change]. Type parameters on impls must now also appear in the trait ref, self type, or some associated type declared on the impl. This ensures that they are constrianed in some way and that the semantics of the trait system are well-defined (always a good thing). There are three major ways to fix this error: 1. Convert the trait to use associated types; most often the type parameters are not constrained because they are in fact outputs of the impl. 2. Move the type parameters to methods. 3. Add an additional type parameter to the self type or trait so that the unused parameter can appear there. In some cases, it is not possible to fix the impl because the trait definition needs to be changed first (and that may be out of your control). In that case, for the time being, you can opt out of these rules by using `#[old_impl_check]` on the impl and adding a `#![feature(old_impl_check)]` to your crate declaration. --- src/librustc/lint/builtin.rs | 1 + src/librustc_typeck/collect.rs | 100 ++++++++++++++++++++++++++++++++- src/libsyntax/feature_gate.rs | 10 ++++ 3 files changed, 110 insertions(+), 1 deletion(-) diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 425e34cd9f042..69da0f9a2109b 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -669,6 +669,7 @@ impl LintPass for UnusedAttributes { // FIXME: #19470 this shouldn't be needed forever "old_orphan_check", + "old_impl_check", ]; static CRATE_ATTRS: &'static [&'static str] = &[ diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index bbafcdae1bba1..137f33d301d19 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -35,7 +35,7 @@ use middle::lang_items::SizedTraitLangItem; use middle::region; use middle::resolve_lifetime; use middle::subst; -use middle::subst::{Substs}; +use middle::subst::{Substs, TypeSpace}; use middle::ty::{AsPredicate, ImplContainer, ImplOrTraitItemContainer, TraitContainer}; use middle::ty::{self, RegionEscape, Ty, TypeScheme}; use middle::ty_fold::{self, TypeFolder, TypeFoldable}; @@ -47,6 +47,7 @@ use util::ppaux; use util::ppaux::{Repr,UserString}; use write_ty_to_tcx; +use std::collections::HashSet; use std::rc::Rc; use syntax::abi; @@ -644,6 +645,10 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { Some(selfty), None); } + + enforce_impl_ty_params_are_constrained(ccx.tcx, + generics, + local_def(it.id)); }, ast::ItemTrait(_, _, _, ref trait_methods) => { let trait_def = trait_def_of_item(ccx, it); @@ -1605,3 +1610,96 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( }) } } + +/// Checks that all the type parameters on an impl +fn enforce_impl_ty_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, + ast_generics: &ast::Generics, + impl_def_id: ast::DefId) +{ + let impl_scheme = ty::lookup_item_type(tcx, impl_def_id); + let impl_trait_ref = ty::impl_trait_ref(tcx, impl_def_id); + + // The trait reference is an input, so find all type parameters + // reachable from there, to start (if this is an inherent impl, + // then just examine the self type). + let mut input_parameters: HashSet<_> = + impl_trait_ref.iter() + .flat_map(|t| t.input_types().iter()) // Types in trait ref, if any + .chain(Some(impl_scheme.ty).iter()) // Self type, always + .flat_map(|t| t.walk()) + .filter_map(to_opt_param_ty) + .collect(); + + loop { + let num_inputs = input_parameters.len(); + + let mut projection_predicates = + impl_scheme.generics.predicates + .iter() + .filter_map(|predicate| { + match *predicate { + // Ignore higher-ranked binders. For the purposes + // of this check, they don't matter because they + // only affect named regions, and we're just + // concerned about type parameters here. + ty::Predicate::Projection(ref data) => Some(data.0.clone()), + _ => None, + } + }); + + for projection in projection_predicates { + // Special case: watch out for some kind of sneaky attempt + // to project out an associated type defined by this very trait. + if Some(projection.projection_ty.trait_ref.clone()) == impl_trait_ref { + continue; + } + + let relies_only_on_inputs = + projection.projection_ty.trait_ref.input_types().iter() + .flat_map(|t| t.walk()) + .filter_map(to_opt_param_ty) + .all(|t| input_parameters.contains(&t)); + + if relies_only_on_inputs { + input_parameters.extend( + projection.ty.walk().filter_map(to_opt_param_ty)); + } + } + + if input_parameters.len() == num_inputs { + break; + } + } + + for (index, ty_param) in ast_generics.ty_params.iter().enumerate() { + let param_ty = ty::ParamTy { space: TypeSpace, + idx: index as u32, + name: ty_param.ident.name }; + if !input_parameters.contains(¶m_ty) { + if ty::has_attr(tcx, impl_def_id, "old_impl_check") { + tcx.sess.span_warn( + ty_param.span, + format!("the type parameter `{}` is not constrained by the \ + impl trait, self type, or predicates", + param_ty.user_string(tcx)).as_slice()); + } else { + tcx.sess.span_err( + ty_param.span, + format!("the type parameter `{}` is not constrained by the \ + impl trait, self type, or predicates", + param_ty.user_string(tcx)).as_slice()); + tcx.sess.span_help( + ty_param.span, + format!("you can temporarily opt out of this rule by placing \ + the `#[old_impl_check]` attribute on the impl").as_slice()); + } + } + } + + fn to_opt_param_ty<'tcx>(ty: Ty<'tcx>) -> Option { + match ty.sty { + ty::ty_param(ref d) => Some(d.clone()), + _ => None, + } + } +} diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 0810d4ee93ac7..8132c9fe78b67 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -86,6 +86,9 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[ // A way to temporarily opt out of the new orphan rules. This will *never* be accepted. ("old_orphan_check", Deprecated), + // A way to temporarily opt out of the new impl rules. This will *never* be accepted. + ("old_impl_check", Deprecated), + // OIBIT specific features ("optin_builtin_traits", Active), @@ -294,6 +297,13 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { i.span, "the new orphan check rules will eventually be strictly enforced"); } + + if attr::contains_name(i.attrs[], + "old_impl_check") { + self.gate_feature("old_impl_check", + i.span, + "`#[old_impl_check]` will be removed in the future"); + } } _ => {} From d91323992c7597311d32867c89bc997a9f0c160d Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 5 Jan 2015 15:56:07 -0500 Subject: [PATCH 36/49] Fix fallout in tests. --- src/test/auxiliary/nested_item.rs | 8 ++++---- src/test/compile-fail/coherence-all-remote.rs | 4 ++-- src/test/compile-fail/issue-12028.rs | 19 ++++++++++--------- src/test/compile-fail/issue-13853-5.rs | 2 +- src/test/compile-fail/issue-16562.rs | 2 +- src/test/run-pass/issue-3743.rs | 12 +++++++++--- 6 files changed, 27 insertions(+), 20 deletions(-) diff --git a/src/test/auxiliary/nested_item.rs b/src/test/auxiliary/nested_item.rs index 1a2f429c9ebc1..21784bda27a8f 100644 --- a/src/test/auxiliary/nested_item.rs +++ b/src/test/auxiliary/nested_item.rs @@ -18,8 +18,8 @@ pub fn foo() -> int { // issue 8134 struct Foo; -impl Foo { - pub fn foo(&self) { +impl Foo { + pub fn foo(&self) { static X: uint = 1; } } @@ -33,8 +33,8 @@ impl> Parser { } struct Bar; -impl Foo { - pub fn bar(&self) { +impl Foo { + pub fn bar(&self) { static X: uint = 1; } } diff --git a/src/test/compile-fail/coherence-all-remote.rs b/src/test/compile-fail/coherence-all-remote.rs index d88b8751ea7b0..d86256a77765e 100644 --- a/src/test/compile-fail/coherence-all-remote.rs +++ b/src/test/compile-fail/coherence-all-remote.rs @@ -11,9 +11,9 @@ // aux-build:coherence-lib.rs extern crate "coherence-lib" as lib; -use lib::Remote; +use lib::Remote1; -impl Remote for int { } +impl Remote1 for int { } //~^ ERROR E0117 fn main() { } diff --git a/src/test/compile-fail/issue-12028.rs b/src/test/compile-fail/issue-12028.rs index 78502efdec520..24ffc5e9ee373 100644 --- a/src/test/compile-fail/issue-12028.rs +++ b/src/test/compile-fail/issue-12028.rs @@ -22,27 +22,28 @@ trait Stream { fn result(&self) -> u64; } -trait StreamHasher { - fn stream(&self) -> S; +trait StreamHasher { + type S : Stream; + fn stream(&self) -> Self::S; } ////////////////////////////////////////////////////////////////////////////// -trait StreamHash>: Hash { - fn input_stream(&self, stream: &mut S); +trait StreamHash: Hash { + fn input_stream(&self, stream: &mut H::S); } -impl> Hash for u8 { +impl Hash for u8 { fn hash2(&self, hasher: &H) -> u64 { let mut stream = hasher.stream(); self.input_stream(&mut stream); //~ ERROR type annotations required - stream.result() + Stream::result(&stream) } } -impl> StreamHash for u8 { - fn input_stream(&self, stream: &mut S) { - stream.input(&[*self]); +impl StreamHash for u8 { + fn input_stream(&self, stream: &mut H::S) { + Stream::input(&*stream, &[*self]); } } diff --git a/src/test/compile-fail/issue-13853-5.rs b/src/test/compile-fail/issue-13853-5.rs index b3a4f341f8448..6a017f7bb30c1 100644 --- a/src/test/compile-fail/issue-13853-5.rs +++ b/src/test/compile-fail/issue-13853-5.rs @@ -15,7 +15,7 @@ trait Deserializable { } impl<'a, T: Deserializable> Deserializable for &'a str { - //~^ ERROR unable to infer enough type information + //~^ ERROR type parameter `T` is not constrained fn deserialize_token>(_x: D, _y: &'a str) -> &'a str { } } diff --git a/src/test/compile-fail/issue-16562.rs b/src/test/compile-fail/issue-16562.rs index 3c784c3b770e4..626a442a2c355 100644 --- a/src/test/compile-fail/issue-16562.rs +++ b/src/test/compile-fail/issue-16562.rs @@ -18,7 +18,7 @@ struct Col { trait Collection { fn len(&self) -> uint; } impl Collection for Col { -//~^ ERROR unable to infer enough type information +//~^ ERROR type parameter `T` is not constrained fn len(&self) -> uint { unimplemented!() } diff --git a/src/test/run-pass/issue-3743.rs b/src/test/run-pass/issue-3743.rs index 43852fb332400..382ea0c575887 100644 --- a/src/test/run-pass/issue-3743.rs +++ b/src/test/run-pass/issue-3743.rs @@ -30,17 +30,23 @@ impl Vec2 { } // Right-hand-side operator visitor pattern -trait RhsOfVec2Mul { fn mul_vec2_by(&self, lhs: &Vec2) -> Result; } +trait RhsOfVec2Mul { + type Result; + + fn mul_vec2_by(&self, lhs: &Vec2) -> Self::Result; +} // Vec2's implementation of Mul "from the other side" using the above trait -impl> Mul for Vec2 { +impl> Mul for Vec2 { type Output = Res; fn mul(self, rhs: Rhs) -> Res { rhs.mul_vec2_by(&self) } } // Implementation of 'f64 as right-hand-side of Vec2::Mul' -impl RhsOfVec2Mul for f64 { +impl RhsOfVec2Mul for f64 { + type Result = Vec2; + fn mul_vec2_by(&self, lhs: &Vec2) -> Vec2 { lhs.vmul(*self) } } From d31105e4f5e880e17f7607addae3573440a4c68a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 5 Jan 2015 16:21:45 -0500 Subject: [PATCH 37/49] Add new tests covering various cases. --- .../compile-fail/impl-unused-tps-inherent.rs | 35 +++++++++ src/test/compile-fail/impl-unused-tps.rs | 72 +++++++++++++++++++ 2 files changed, 107 insertions(+) create mode 100644 src/test/compile-fail/impl-unused-tps-inherent.rs create mode 100644 src/test/compile-fail/impl-unused-tps.rs diff --git a/src/test/compile-fail/impl-unused-tps-inherent.rs b/src/test/compile-fail/impl-unused-tps-inherent.rs new file mode 100644 index 0000000000000..3803bb9b045ed --- /dev/null +++ b/src/test/compile-fail/impl-unused-tps-inherent.rs @@ -0,0 +1,35 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct MyType; + +struct MyType1(T); + +trait Bar { + type Out; +} + +impl MyType { + //~^ ERROR the type parameter `T` is not constrained +} + +impl MyType1 { + // OK, T is used in `Foo`. +} + +impl MyType1 { + //~^ ERROR the type parameter `U` is not constrained +} + +impl MyType1 where T: Bar { + // OK, T is used in `Foo`. +} + +fn main() { } diff --git a/src/test/compile-fail/impl-unused-tps.rs b/src/test/compile-fail/impl-unused-tps.rs new file mode 100644 index 0000000000000..99c6c6b89858c --- /dev/null +++ b/src/test/compile-fail/impl-unused-tps.rs @@ -0,0 +1,72 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait Foo { + fn get(&self, A: &A) { } +} + +trait Bar { + type Out; +} + +impl Foo for [int;0] { + // OK, T is used in `Foo`. +} + +impl Foo for [int;1] { + //~^ ERROR the type parameter `U` is not constrained +} + +impl Foo for [int;2] where T : Bar { + // OK, `U` is now constrained by the output type parameter. +} + +impl,U> Foo for [int;3] { + // OK, same as above but written differently. +} + +impl Foo for U { + // OK, T, U are used everywhere. Note that the coherence check + // hasn't executed yet, so no errors about overlap. +} + +impl Bar for T { + //~^ ERROR the type parameter `U` is not constrained + + type Out = U; + + // Using `U` in an associated type within the impl is not good enough! +} + +impl Bar for T + where T : Bar +{ + //~^^^ ERROR the type parameter `U` is not constrained + + // This crafty self-referential attempt is still no good. +} + +impl Foo for T + where (T,U): Bar +{ + //~^^^ ERROR the type parameter `U` is not constrained + //~| ERROR the type parameter `V` is not constrained + + // Here, `V` is bound by an output type parameter, but the inputs + // are not themselves constrained. +} + +impl Foo<(T,U)> for T + where (T,U): Bar +{ + // As above, but both T and U ARE constrained. +} + +fn main() { } From 44440e5c18a1dbcc9685866ffffe00c508929079 Mon Sep 17 00:00:00 2001 From: Sean McArthur Date: Sat, 20 Dec 2014 00:09:35 -0800 Subject: [PATCH 38/49] core: split into fmt::Show and fmt::String fmt::Show is for debugging, and can and should be implemented for all public types. This trait is used with `{:?}` syntax. There still exists #[derive(Show)]. fmt::String is for types that faithfully be represented as a String. Because of this, there is no way to derive fmt::String, all implementations must be purposeful. It is used by the default format syntax, `{}`. This will break most instances of `{}`, since that now requires the type to impl fmt::String. In most cases, replacing `{}` with `{:?}` is the correct fix. Types that were being printed specifically for users should receive a fmt::String implementation to fix this. Part of #20013 [breaking-change] --- src/compiletest/common.rs | 13 +- src/compiletest/compiletest.rs | 26 +- src/compiletest/errors.rs | 2 +- src/compiletest/runtest.rs | 22 +- src/liballoc/arc.rs | 4 +- src/liballoc/boxed.rs | 8 +- src/liballoc/rc.rs | 8 +- src/libcollections/bit.rs | 4 +- src/libcollections/btree/map.rs | 4 +- src/libcollections/btree/node.rs | 2 +- src/libcollections/btree/set.rs | 4 +- src/libcollections/dlist.rs | 4 +- src/libcollections/enum_set.rs | 10 +- src/libcollections/ring_buf.rs | 4 +- src/libcollections/slice.rs | 16 +- src/libcollections/string.rs | 40 +- src/libcollections/vec.rs | 9 +- src/libcollections/vec_map.rs | 10 +- src/libcore/any.rs | 2 +- src/libcore/borrow.rs | 20 +- src/libcore/cell.rs | 11 - src/libcore/fmt/mod.rs | 139 +++++- src/libcore/fmt/num.rs | 50 ++- src/libcore/macros.rs | 2 +- src/libcore/result.rs | 8 +- src/libcore/str/mod.rs | 2 +- src/libcoretest/any.rs | 16 +- src/libcoretest/cell.rs | 8 +- src/libcoretest/fmt/num.rs | 24 ++ src/libcoretest/result.rs | 8 +- src/libcoretest/tuple.rs | 12 +- src/libfmt_macros/lib.rs | 6 +- src/libgetopts/lib.rs | 22 +- src/liblog/directive.rs | 2 +- src/liblog/lib.rs | 18 +- src/librbml/lib.rs | 60 +-- src/libregex/lib.rs | 1 - src/libregex/parse.rs | 26 +- src/libregex/re.rs | 11 +- src/librustc/lint/builtin.rs | 3 +- src/librustc/metadata/csearch.rs | 4 +- src/librustc/metadata/encoder.rs | 4 +- src/librustc/metadata/tydecode.rs | 4 +- src/librustc/middle/astencode.rs | 8 +- src/librustc/middle/cfg/construct.rs | 6 +- src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/check_match.rs | 4 +- src/librustc/middle/check_rvalues.rs | 2 +- src/librustc/middle/dataflow.rs | 20 +- src/librustc/middle/dependency_format.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 6 +- src/librustc/middle/graph.rs | 2 +- src/librustc/middle/infer/coercion.rs | 14 +- src/librustc/middle/infer/combine.rs | 10 +- src/librustc/middle/infer/error_reporting.rs | 4 +- .../middle/infer/higher_ranked/mod.rs | 16 +- src/librustc/middle/infer/mod.rs | 6 +- .../middle/infer/region_inference/graphviz.rs | 8 +- .../middle/infer/region_inference/mod.rs | 48 +-- src/librustc/middle/infer/type_variable.rs | 2 +- src/librustc/middle/infer/unify.rs | 2 +- src/librustc/middle/intrinsicck.rs | 2 +- src/librustc/middle/liveness.rs | 36 +- src/librustc/middle/mem_categorization.rs | 8 +- src/librustc/middle/privacy.rs | 20 +- src/librustc/middle/region.rs | 48 +-- src/librustc/middle/resolve_lifetime.rs | 16 +- src/librustc/middle/stability.rs | 4 +- src/librustc/middle/subst.rs | 10 +- src/librustc/middle/traits/mod.rs | 4 +- src/librustc/middle/traits/object_safety.rs | 2 +- src/librustc/middle/traits/select.rs | 14 +- src/librustc/middle/traits/util.rs | 6 +- src/librustc/middle/ty.rs | 120 +++--- src/librustc/middle/ty_walk.rs | 4 +- src/librustc/util/common.rs | 2 +- src/librustc/util/ppaux.rs | 51 +-- src/librustc_back/archive.rs | 4 +- src/librustc_back/rpath.rs | 4 +- src/librustc_back/svh.rs | 8 + src/librustc_back/target/mod.rs | 8 +- src/librustc_borrowck/borrowck/check_loans.rs | 14 +- src/librustc_borrowck/borrowck/fragments.rs | 16 +- .../borrowck/gather_loans/gather_moves.rs | 2 +- .../borrowck/gather_loans/mod.rs | 22 +- src/librustc_borrowck/borrowck/mod.rs | 6 +- src/librustc_borrowck/borrowck/move_data.rs | 8 +- src/librustc_borrowck/graphviz.rs | 2 +- src/librustc_driver/driver.rs | 2 +- src/librustc_driver/pretty.rs | 8 +- src/librustc_resolve/build_reduced_graph.rs | 4 +- src/librustc_resolve/check_unused.rs | 2 +- src/librustc_resolve/lib.rs | 42 +- src/librustc_resolve/record_exports.rs | 4 +- src/librustc_trans/back/link.rs | 4 +- src/librustc_trans/back/write.rs | 4 +- src/librustc_trans/save/mod.rs | 7 +- src/librustc_trans/trans/_match.rs | 4 +- src/librustc_trans/trans/adt.rs | 8 +- src/librustc_trans/trans/base.rs | 8 +- src/librustc_trans/trans/callee.rs | 6 +- src/librustc_trans/trans/cleanup.rs | 22 +- src/librustc_trans/trans/closure.rs | 4 +- src/librustc_trans/trans/common.rs | 4 +- src/librustc_trans/trans/consts.rs | 6 +- src/librustc_trans/trans/controlflow.rs | 2 +- src/librustc_trans/trans/datum.rs | 2 +- src/librustc_trans/trans/debuginfo.rs | 26 +- src/librustc_trans/trans/expr.rs | 22 +- src/librustc_trans/trans/meth.rs | 6 +- src/librustc_trans/trans/monomorphize.rs | 10 +- src/librustc_trans/trans/type_of.rs | 8 +- src/librustc_typeck/astconv.rs | 6 +- src/librustc_typeck/check/closure.rs | 6 +- src/librustc_typeck/check/method/confirm.rs | 2 +- src/librustc_typeck/check/method/mod.rs | 4 +- src/librustc_typeck/check/method/probe.rs | 12 +- src/librustc_typeck/check/mod.rs | 14 +- src/librustc_typeck/check/regionck.rs | 14 +- src/librustc_typeck/check/upvar.rs | 6 +- src/librustc_typeck/check/writeback.rs | 4 +- src/librustc_typeck/coherence/mod.rs | 6 +- src/librustc_typeck/collect.rs | 12 +- src/librustc_typeck/variance.rs | 20 +- src/librustdoc/clean/inline.rs | 4 +- src/librustdoc/clean/mod.rs | 50 +-- src/librustdoc/core.rs | 2 +- src/librustdoc/html/escape.rs | 8 + src/librustdoc/html/format.rs | 201 ++++++++- src/librustdoc/html/item_type.rs | 8 + src/librustdoc/html/layout.rs | 2 +- src/librustdoc/html/markdown.rs | 22 +- src/librustdoc/html/render.rs | 40 +- src/librustdoc/html/toc.rs | 8 + src/librustdoc/lib.rs | 4 +- src/librustdoc/test.rs | 2 +- src/librustdoc/visit_ast.rs | 2 +- src/libserialize/base64.rs | 2 +- src/libserialize/hex.rs | 4 +- src/libserialize/json.rs | 56 +-- src/libstd/collections/hash/map.rs | 12 +- src/libstd/collections/hash/set.rs | 12 +- src/libstd/fmt.rs | 36 +- src/libstd/io/fs.rs | 68 +-- src/libstd/io/mod.rs | 14 +- src/libstd/io/net/addrinfo.rs | 10 +- src/libstd/io/net/ip.rs | 8 +- src/libstd/io/process.rs | 15 + src/libstd/io/stdio.rs | 2 +- src/libstd/macros.rs | 2 +- src/libstd/os.rs | 4 +- src/libstd/path/mod.rs | 31 +- src/libstd/path/posix.rs | 101 ++--- src/libstd/path/windows.rs | 119 ++--- src/libstd/rand/mod.rs | 4 +- src/libstd/rand/reader.rs | 2 +- src/libstd/sys/unix/backtrace.rs | 2 +- src/libstd/sys/unix/fs.rs | 2 +- src/libstd/sys/unix/process.rs | 14 +- src/libstd/time/duration.rs | 4 +- src/libsyntax/abi.rs | 14 +- src/libsyntax/ast.rs | 67 ++- src/libsyntax/ast_map/mod.rs | 17 +- src/libsyntax/attr.rs | 7 + src/libsyntax/codemap.rs | 6 +- src/libsyntax/diagnostic.rs | 10 +- src/libsyntax/ext/deriving/show.rs | 4 +- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/format.rs | 2 +- src/libsyntax/ext/mtwt.rs | 2 +- src/libsyntax/ext/source_util.rs | 8 +- src/libsyntax/ext/tt/transcribe.rs | 4 +- src/libsyntax/parse/attr.rs | 4 +- src/libsyntax/parse/lexer/mod.rs | 28 +- src/libsyntax/parse/mod.rs | 14 +- src/libsyntax/parse/parser.rs | 6 +- src/libsyntax/parse/token.rs | 6 + src/libsyntax/test.rs | 2 +- src/libterm/terminfo/mod.rs | 4 +- src/libterm/terminfo/parm.rs | 6 +- src/libterm/terminfo/parser/compiled.rs | 2 +- src/libterm/terminfo/searcher.rs | 4 +- src/libtest/lib.rs | 20 +- src/libtest/stats.rs | 6 +- src/llvm | 2 +- src/rust-installer | 2 +- src/test/auxiliary/cci_class_cast.rs | 2 +- .../borrowck-move-out-of-vec-tail.rs | 2 +- src/test/compile-fail/copy-a-resource.rs | 2 +- src/test/compile-fail/ifmt-bad-arg.rs | 2 +- src/test/compile-fail/issue-14853.rs | 2 +- src/test/compile-fail/issue-15094.rs | 2 +- src/test/compile-fail/issue-17728.rs | 4 +- src/test/compile-fail/issue-5062.rs | 2 +- src/test/compile-fail/issue-6458-2.rs | 2 +- src/test/compile-fail/linkage3.rs | 2 +- .../compile-fail/lint-uppercase-variables.rs | 2 +- .../compile-fail/liveness-use-after-send.rs | 4 +- src/test/compile-fail/no-send-res-ports.rs | 2 +- src/test/compile-fail/noncopyable-class.rs | 2 +- .../compile-fail/packed-struct-transmute.rs | 2 +- .../compile-fail/static-reference-to-fn-2.rs | 10 +- src/test/compile-fail/unique-pinned-nocopy.rs | 2 +- src/test/compile-fail/unique-vec-res.rs | 4 +- ...use-after-move-implicity-coerced-object.rs | 2 +- src/test/compile-fail/vec-res-add.rs | 2 +- src/test/run-fail/assert-eq-macro-panic.rs | 2 +- src/test/run-pass/borrowck-mut-uniq.rs | 4 +- src/test/run-pass/class-separate-impl.rs | 2 +- .../run-pass/conditional-debug-macro-off.rs | 2 +- .../run-pass/conditional-debug-macro-on.rs | 2 +- src/test/run-pass/deriving-in-fn.rs | 2 +- src/test/run-pass/deriving-show-2.rs | 31 +- src/test/run-pass/deriving-show.rs | 10 +- src/test/run-pass/dst-index.rs | 2 +- src/test/run-pass/enum-discrim-width-stuff.rs | 4 +- src/test/run-pass/functional-struct-upd.rs | 2 +- src/test/run-pass/ifmt.rs | 12 +- src/test/run-pass/issue-10396.rs | 2 +- src/test/run-pass/issue-10626.rs | 2 +- src/test/run-pass/issue-11267.rs | 2 +- src/test/run-pass/issue-12744.rs | 2 +- src/test/run-pass/issue-13434.rs | 2 +- src/test/run-pass/issue-1696.rs | 2 +- src/test/run-pass/issue-19135.rs | 2 +- src/test/run-pass/issue-19358.rs | 2 +- src/test/run-pass/issue-3109.rs | 2 +- src/test/run-pass/issue-3556.rs | 2 +- src/test/run-pass/issue-3559.rs | 4 +- src/test/run-pass/issue-3563-3.rs | 2 +- src/test/run-pass/issue-3794.rs | 2 +- src/test/run-pass/issue-4252.rs | 4 +- src/test/run-pass/issue-7563.rs | 4 +- src/test/run-pass/issue-8898.rs | 4 +- .../log-knows-the-names-of-variants-in-std.rs | 8 +- .../log-knows-the-names-of-variants.rs | 6 +- src/test/run-pass/log-poly.rs | 8 +- src/test/run-pass/logging-only-prints-once.rs | 2 +- src/test/run-pass/new-impl-syntax.rs | 8 +- .../run-pass/overloaded-index-assoc-list.rs | 2 +- src/test/run-pass/rec-align-u32.rs | 10 +- src/test/run-pass/rec-align-u64.rs | 10 +- .../run-pass/resource-assign-is-not-copy.rs | 2 +- src/test/run-pass/running-with-no-runtime.rs | 4 +- src/test/run-pass/show-boxed-slice.rs | 2 +- src/test/run-pass/small-enums-with-fields.rs | 16 +- src/test/run-pass/supported-cast.rs | 408 +++++++++--------- src/test/run-pass/tag-align-shape.rs | 6 +- src/test/run-pass/tag-disr-val-shape.rs | 6 +- src/test/run-pass/trivial-message.rs | 2 +- src/test/run-pass/tuple-struct-construct.rs | 2 +- src/test/run-pass/vec-to_str.rs | 6 +- 252 files changed, 2005 insertions(+), 1375 deletions(-) diff --git a/src/compiletest/common.rs b/src/compiletest/common.rs index 202a87fcdc9e7..c29f74d741810 100644 --- a/src/compiletest/common.rs +++ b/src/compiletest/common.rs @@ -43,9 +43,9 @@ impl FromStr for Mode { } } -impl fmt::Show for Mode { +impl fmt::String for Mode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let msg = match *self { + fmt::String::fmt(match *self { CompileFail => "compile-fail", RunFail => "run-fail", RunPass => "run-pass", @@ -54,8 +54,13 @@ impl fmt::Show for Mode { DebugInfoGdb => "debuginfo-gdb", DebugInfoLldb => "debuginfo-lldb", Codegen => "codegen", - }; - msg.fmt(f) + }, f) + } +} + +impl fmt::Show for Mode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) } } diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 0ce31a335d8ab..23674efe9683f 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -108,7 +108,7 @@ pub fn parse_config(args: Vec ) -> Config { let matches = &match getopts::getopts(args_.as_slice(), groups.as_slice()) { Ok(m) => m, - Err(f) => panic!("{}", f) + Err(f) => panic!("{:?}", f) }; if matches.opt_present("h") || matches.opt_present("help") { @@ -127,7 +127,7 @@ pub fn parse_config(args: Vec ) -> Config { match regex::Regex::new(s) { Ok(re) => Some(re), Err(e) => { - println!("failed to parse filter /{}/: {}", s, e); + println!("failed to parse filter /{}/: {:?}", s, e); panic!() } } @@ -186,11 +186,11 @@ pub fn parse_config(args: Vec ) -> Config { pub fn log_config(config: &Config) { let c = config; logv(c, format!("configuration:")); - logv(c, format!("compile_lib_path: {}", config.compile_lib_path)); - logv(c, format!("run_lib_path: {}", config.run_lib_path)); - logv(c, format!("rustc_path: {}", config.rustc_path.display())); - logv(c, format!("src_base: {}", config.src_base.display())); - logv(c, format!("build_base: {}", config.build_base.display())); + logv(c, format!("compile_lib_path: {:?}", config.compile_lib_path)); + logv(c, format!("run_lib_path: {:?}", config.run_lib_path)); + logv(c, format!("rustc_path: {:?}", config.rustc_path.display())); + logv(c, format!("src_base: {:?}", config.src_base.display())); + logv(c, format!("build_base: {:?}", config.build_base.display())); logv(c, format!("stage_id: {}", config.stage_id)); logv(c, format!("mode: {}", config.mode)); logv(c, format!("run_ignored: {}", config.run_ignored)); @@ -206,10 +206,10 @@ pub fn log_config(config: &Config) { logv(c, format!("jit: {}", config.jit)); logv(c, format!("target: {}", config.target)); logv(c, format!("host: {}", config.host)); - logv(c, format!("android-cross-path: {}", + logv(c, format!("android-cross-path: {:?}", config.android_cross_path.display())); - logv(c, format!("adb_path: {}", config.adb_path)); - logv(c, format!("adb_test_dir: {}", config.adb_test_dir)); + logv(c, format!("adb_path: {:?}", config.adb_path)); + logv(c, format!("adb_test_dir: {:?}", config.adb_test_dir)); logv(c, format!("adb_device_status: {}", config.adb_device_status)); match config.test_shard { @@ -271,7 +271,7 @@ pub fn run_tests(config: &Config) { Ok(true) => {} Ok(false) => panic!("Some tests failed"), Err(e) => { - println!("I/O failure during tests: {}", e); + println!("I/O failure during tests: {:?}", e); } } } @@ -299,13 +299,13 @@ pub fn test_opts(config: &Config) -> test::TestOpts { } pub fn make_tests(config: &Config) -> Vec { - debug!("making tests from {}", + debug!("making tests from {:?}", config.src_base.display()); let mut tests = Vec::new(); let dirs = fs::readdir(&config.src_base).unwrap(); for file in dirs.iter() { let file = file.clone(); - debug!("inspecting file {}", file.display()); + debug!("inspecting file {:?}", file.display()); if is_test(config, &file) { let t = make_test(config, &file, || { match config.mode { diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index f330bb3143eab..dcfac688c7f62 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -84,7 +84,7 @@ fn parse_expected(last_nonfollow_error: Option, (which, line) }; - debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg); + debug!("line={} which={:?} kind={:?} msg={:?}", line_num, which, kind, msg); Some((which, ExpectedError { line: line, kind: kind, msg: msg, })) diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 875061e69b7a2..325e0801c89b2 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -61,7 +61,7 @@ pub fn run_metrics(config: Config, testfile: String, mm: &mut MetricMap) { print!("\n\n"); } let testfile = Path::new(testfile); - debug!("running {}", testfile.display()); + debug!("running {:?}", testfile.display()); let props = header::load_props(&testfile); debug!("loaded props"); match config.mode { @@ -141,7 +141,7 @@ fn check_correct_failure_status(proc_res: &ProcRes) { static RUST_ERR: int = 101; if !proc_res.status.matches_exit_status(RUST_ERR) { fatal_proc_rec( - format!("failure produced the wrong error: {}", + format!("failure produced the wrong error: {:?}", proc_res.status).as_slice(), proc_res); } @@ -410,7 +410,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { ], vec!(("".to_string(), "".to_string())), Some("".to_string())) - .expect(format!("failed to exec `{}`", config.adb_path).as_slice()); + .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice()); procsrv::run("", config.adb_path.as_slice(), @@ -422,7 +422,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { ], vec!(("".to_string(), "".to_string())), Some("".to_string())) - .expect(format!("failed to exec `{}`", config.adb_path).as_slice()); + .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice()); let adb_arg = format!("export LD_LIBRARY_PATH={}; \ gdbserver :5039 {}/{}", @@ -443,7 +443,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { vec!(("".to_string(), "".to_string())), Some("".to_string())) - .expect(format!("failed to exec `{}`", config.adb_path).as_slice()); + .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice()); loop { //waiting 1 second for gdbserver start timer::sleep(Duration::milliseconds(1000)); @@ -481,7 +481,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { debugger_opts.as_slice(), vec!(("".to_string(), "".to_string())), None) - .expect(format!("failed to exec `{}`", gdb_path).as_slice()); + .expect(format!("failed to exec `{:?}`", gdb_path).as_slice()); let cmdline = { let cmdline = make_cmdline("", "arm-linux-androideabi-gdb", @@ -548,7 +548,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { // Add line breakpoints for line in breakpoint_lines.iter() { - script_str.push_str(format!("break '{}':{}\n", + script_str.push_str(format!("break '{:?}':{}\n", testfile.filename_display(), *line)[]); } @@ -889,7 +889,7 @@ fn check_error_patterns(props: &TestProps, output_to_check: &str, proc_res: &ProcRes) { if props.error_patterns.is_empty() { - fatal(format!("no error pattern specified in {}", + fatal(format!("no error pattern specified in {:?}", testfile.display()).as_slice()); } let mut next_err_idx = 0u; @@ -955,7 +955,7 @@ fn check_expected_errors(expected_errors: Vec , } let prefixes = expected_errors.iter().map(|ee| { - format!("{}:{}:", testfile.display(), ee.line) + format!("{:?}:{}:", testfile.display(), ee.line) }).collect:: >(); #[cfg(windows)] @@ -1191,7 +1191,7 @@ fn compose_and_run_compiler( None); if !auxres.status.success() { fatal_proc_rec( - format!("auxiliary build of {} failed to compile: ", + format!("auxiliary build of {:?} failed to compile: ", abs_ab.display()).as_slice(), &auxres); } @@ -1601,7 +1601,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) { .expect(format!("failed to exec `{}`", config.adb_path).as_slice()); if config.verbose { - println!("push ({}) {} {} {}", + println!("push ({}) {:?} {} {}", config.target, file.display(), copy_result.out, copy_result.err); } diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 25f80ad11bd11..7789620a64fe3 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -581,7 +581,7 @@ impl Eq for Arc {} impl fmt::Show for Arc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - (**self).fmt(f) + write!(f, "Arc({:?})", (**self)) } } @@ -794,7 +794,7 @@ mod tests { #[test] fn show_arc() { let a = Arc::new(5u32); - assert!(format!("{}", a) == "5") + assert!(format!("{:?}", a) == "Arc(5u32)") } // Make sure deriving works with Arc diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 6df8bb5f7aaf4..b4eb71df16768 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -145,7 +145,13 @@ impl BoxAny for Box { impl fmt::Show for Box { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - (**self).fmt(f) + write!(f, "Box({:?})", &**self) + } +} + +impl fmt::String for Box { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(&**self, f) } } diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 175bba4e71dc4..91566e89a1642 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -607,7 +607,7 @@ impl> Hash for Rc { #[experimental = "Show is experimental."] impl fmt::Show for Rc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - (**self).fmt(f) + write!(f, "Rc({:?})", **self) } } @@ -962,4 +962,10 @@ mod tests { assert!(cow1_weak.upgrade().is_none()); } + #[test] + fn test_show() { + let foo = Rc::new(75u); + assert!(format!("{:?}", foo) == "Rc(75u)") + } + } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index c092e000215d3..2a7efdd533340 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -1729,13 +1729,13 @@ impl BitvSet { impl fmt::Show for BitvSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(write!(fmt, "{{")); + try!(write!(fmt, "BitvSet {{")); let mut first = true; for n in self.iter() { if !first { try!(write!(fmt, ", ")); } - try!(write!(fmt, "{}", n)); + try!(write!(fmt, "{:?}", n)); first = false; } write!(fmt, "}}") diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index b85ea65f5ce58..0dd345110d73d 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -866,11 +866,11 @@ impl Ord for BTreeMap { #[stable] impl Show for BTreeMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{{")); + try!(write!(f, "BTreeMap {{")); for (i, (k, v)) in self.iter().enumerate() { if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {}", *k, *v)); + try!(write!(f, "{:?}: {:?}", *k, *v)); } write!(f, "}}") diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 0a93bbf89c997..a764264fd1e68 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -493,7 +493,7 @@ impl Clone for Node { /// // Now the handle still points at index 75, but on the small node, which has no index 75. /// flag.set(true); /// -/// println!("Uninitialized memory: {}", handle.into_kv()); +/// println!("Uninitialized memory: {:?}", handle.into_kv()); /// } /// ``` #[derive(Copy)] diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 98f1633217060..44140154ae48e 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -556,11 +556,11 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet> for &'a BTreeSet { #[stable] impl Show for BTreeSet { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{{")); + try!(write!(f, "BTreeSet {{")); for (i, x) in self.iter().enumerate() { if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}", *x)); + try!(write!(f, "{:?}", *x)); } write!(f, "}}") diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 5e08f90ce1c53..4ebd3dc63b698 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -663,11 +663,11 @@ impl Clone for DList { #[stable] impl fmt::Show for DList { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "[")); + try!(write!(f, "DList [")); for (i, e) in self.iter().enumerate() { if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}", *e)); + try!(write!(f, "{:?}", *e)); } write!(f, "]") diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 4b94348e87ae3..1b852d0ba680d 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -33,13 +33,13 @@ impl Copy for EnumSet {} impl fmt::Show for EnumSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(write!(fmt, "{{")); + try!(write!(fmt, "EnumSet {{")); let mut first = true; for e in self.iter() { if !first { try!(write!(fmt, ", ")); } - try!(write!(fmt, "{}", e)); + try!(write!(fmt, "{:?}", e)); first = false; } write!(fmt, "}}") @@ -287,11 +287,11 @@ mod test { #[test] fn test_show() { let mut e = EnumSet::new(); - assert_eq!("{}", e.to_string()); + assert!(format!("{:?}", e) == "EnumSet {}"); e.insert(A); - assert_eq!("{A}", e.to_string()); + assert!(format!("{:?}", e) == "EnumSet {A}"); e.insert(C); - assert_eq!("{A, C}", e.to_string()); + assert!(format!("{:?}", e) == "EnumSet {A, C}"); } #[test] diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 11775f62b1c54..0f04c86b7b0a2 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -1613,11 +1613,11 @@ impl Extend for RingBuf { #[stable] impl fmt::Show for RingBuf { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "[")); + try!(write!(f, "RingBuf [")); for (i, e) in self.iter().enumerate() { if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}", *e)); + try!(write!(f, "{:?}", *e)); } write!(f, "]") diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 9e5aa7d645ba0..0b2745f335f70 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -2466,25 +2466,25 @@ mod tests { macro_rules! test_show_vec { ($x:expr, $x_str:expr) => ({ let (x, x_str) = ($x, $x_str); - assert_eq!(format!("{}", x), x_str); - assert_eq!(format!("{}", x.as_slice()), x_str); + assert_eq!(format!("{:?}", x), x_str); + assert_eq!(format!("{:?}", x.as_slice()), x_str); }) } let empty: Vec = vec![]; test_show_vec!(empty, "[]"); - test_show_vec!(vec![1i], "[1]"); - test_show_vec!(vec![1i, 2, 3], "[1, 2, 3]"); + test_show_vec!(vec![1i], "[1i]"); + test_show_vec!(vec![1i, 2, 3], "[1i, 2i, 3i]"); test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]], - "[[], [1], [1, 1]]"); + "[[], [1u], [1u, 1u]]"); let empty_mut: &mut [int] = &mut[]; test_show_vec!(empty_mut, "[]"); let v: &mut[int] = &mut[1]; - test_show_vec!(v, "[1]"); + test_show_vec!(v, "[1i]"); let v: &mut[int] = &mut[1, 2, 3]; - test_show_vec!(v, "[1, 2, 3]"); + test_show_vec!(v, "[1i, 2i, 3i]"); let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]]; - test_show_vec!(v, "[[], [1], [1, 1]]"); + test_show_vec!(v, "[[], [1u], [1u, 1u]]"); } #[test] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 0bf311e4d3f6e..c0ade3cc51360 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -677,13 +677,25 @@ impl FromUtf8Error { impl fmt::Show for FromUtf8Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.error.fmt(f) + fmt::String::fmt(self, f) + } +} + +impl fmt::String for FromUtf8Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(&self.error, f) } } impl fmt::Show for FromUtf16Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - "invalid utf-16: lone surrogate found".fmt(f) + fmt::String::fmt(self, f) + } +} + +impl fmt::String for FromUtf16Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt("invalid utf-16: lone surrogate found", f) } } @@ -793,10 +805,17 @@ impl Default for String { } } -#[experimental = "waiting on Show stabilization"] +#[experimental = "waiting on fmt stabilization"] +impl fmt::String for String { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(&**self, f) + } +} + +#[experimental = "waiting on fmt stabilization"] impl fmt::Show for String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - (**self).fmt(f) + fmt::Show::fmt(&**self, f) } } @@ -895,6 +914,8 @@ pub trait ToString { fn to_string(&self) -> String; } +#[cfg(stage0)] +//NOTE(stage0): remove after stage0 snapshot impl ToString for T { fn to_string(&self) -> String { use core::fmt::Writer; @@ -905,6 +926,17 @@ impl ToString for T { } } +#[cfg(not(stage0))] +impl ToString for T { + fn to_string(&self) -> String { + use core::fmt::Writer; + let mut buf = String::new(); + let _ = buf.write_fmt(format_args!("{}", self)); + buf.shrink_to_fit(); + buf + } +} + impl IntoCow<'static, String, str> for String { fn into_cow(self) -> CowString<'static> { Cow::Owned(self) diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 99231e7253c3c..cfe975d92fc70 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1432,7 +1432,14 @@ impl Default for Vec { #[experimental = "waiting on Show stability"] impl fmt::Show for Vec { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_slice().fmt(f) + fmt::Show::fmt(self.as_slice(), f) + } +} + +#[experimental = "waiting on Show stability"] +impl fmt::String for Vec { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self.as_slice(), f) } } diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index cc757b656238e..02878a4d43648 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -488,11 +488,11 @@ impl Ord for VecMap { #[stable] impl fmt::Show for VecMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{{")); + try!(write!(f, "VecMap {{")); for (i, (k, v)) in self.iter().enumerate() { if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {}", k, *v)); + try!(write!(f, "{}: {:?}", k, *v)); } write!(f, "}}") @@ -928,9 +928,9 @@ mod test_map { map.insert(1, 2i); map.insert(3, 4i); - let map_str = map.to_string(); - assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}"); - assert_eq!(format!("{}", empty), "{}"); + let map_str = format!("{:?}", map); + assert!(map_str == "VecMap {1: 2i, 3: 4i}" || map_str == "{3: 4i, 1: 2i}"); + assert_eq!(format!("{:?}", empty), "VecMap {}"); } #[test] diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 33cb335d75645..2c74ad239257f 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -46,7 +46,7 @@ //! // different type: just print it out unadorned. //! match value_any.downcast_ref::() { //! Some(as_string) => { -//! println!("String ({}): {}", as_string.len(), as_string); +//! println!("String ({}): {:?}", as_string.len(), as_string); //! } //! None => { //! println!("{}", value); diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs index 2c08b97635580..8cde33c9408fe 100644 --- a/src/libcore/borrow.rs +++ b/src/libcore/borrow.rs @@ -133,6 +133,7 @@ impl ToOwned for T where T: Clone { /// } /// } /// ``` +//#[deriving(Show)] NOTE(stage0): uncomment after snapshot pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned { /// Borrowed data. Borrowed(&'a B), @@ -141,6 +142,16 @@ pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned { Owned(T) } +//NOTE(stage0): replace with deriving(Show) after snapshot +impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where + B: fmt::String + ToOwned, + T: fmt::String +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + #[stable] impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned { fn clone(&self) -> Cow<'a, T, B> { @@ -237,11 +248,14 @@ impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwne } } -impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where B: fmt::Show + ToOwned, T: fmt::Show { +impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where + B: fmt::String + ToOwned, + T: fmt::String, +{ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - Borrowed(ref b) => fmt::Show::fmt(b, f), - Owned(ref o) => fmt::Show::fmt(o, f), + Borrowed(ref b) => fmt::String::fmt(b, f), + Owned(ref o) => fmt::String::fmt(o, f), } } } diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index fd18d6ac3f3b4..3cc197c323c1d 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -160,7 +160,6 @@ use clone::Clone; use cmp::PartialEq; use default::Default; -use fmt; use kinds::{Copy, Send}; use ops::{Deref, DerefMut, Drop}; use option::Option; @@ -364,16 +363,6 @@ impl PartialEq for RefCell { } } -#[unstable] -impl fmt::Show for RefCell { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.try_borrow() { - Some(val) => write!(f, "{}", val), - None => write!(f, "") - } - } -} - struct BorrowRef<'b> { _borrow: &'b Cell, } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 951f5c29f00e8..ceb9557235562 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -13,7 +13,8 @@ #![allow(unused_variables)] use any; -use cell::{Cell, Ref, RefMut}; +use cell::{Cell, RefCell, Ref, RefMut}; +use char::CharExt; use iter::{Iterator, IteratorExt, range}; use kinds::{Copy, Sized}; use mem; @@ -215,21 +216,37 @@ pub struct Arguments<'a> { args: &'a [Argument<'a>], } +#[cfg(stage0)] +//FIXME: remove after stage0 snapshot impl<'a> Show for Arguments<'a> { fn fmt(&self, fmt: &mut Formatter) -> Result { write(fmt.buf, *self) } } -/// When a format is not otherwise specified, types are formatted by ascribing -/// to this trait. There is not an explicit way of selecting this trait to be -/// used for formatting, it is only if no other format is specified. +#[cfg(not(stage0))] +impl<'a> String for Arguments<'a> { + fn fmt(&self, fmt: &mut Formatter) -> Result { + write(fmt.buf, *self) + } +} + +/// Format trait for the `:?` format. Useful for debugging, most all types +/// should implement this. #[unstable = "I/O and core have yet to be reconciled"] pub trait Show { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } +/// When a value can be semantically expressed as a String, this trait may be +/// used. It corresponds to the default format, `{}`. +#[unstable = "I/O and core have yet to be reconciled"] +pub trait String { + /// Formats the value using the given formatter. + fn fmt(&self, &mut Formatter) -> Result; +} + /// Format trait for the `o` character #[unstable = "I/O and core have yet to be reconciled"] @@ -572,7 +589,7 @@ impl<'a> Formatter<'a> { impl Show for Error { fn fmt(&self, f: &mut Formatter) -> Result { - "an error occurred when formatting an argument".fmt(f) + String::fmt("an error occurred when formatting an argument", f) } } @@ -595,33 +612,86 @@ pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { // Implementations of the core formatting traits -impl<'a, T: ?Sized + Show> Show for &'a T { - fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) } -} -impl<'a, T: ?Sized + Show> Show for &'a mut T { - fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) } +macro_rules! fmt_refs { + ($($tr:ident),*) => { + $( + impl<'a, T: ?Sized + $tr> $tr for &'a T { + fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) } + } + impl<'a, T: ?Sized + $tr> $tr for &'a mut T { + fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) } + } + )* + } } +fmt_refs! { Show, String, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp } + impl Show for bool { fn fmt(&self, f: &mut Formatter) -> Result { - Show::fmt(if *self { "true" } else { "false" }, f) + String::fmt(self, f) } } +impl String for bool { + fn fmt(&self, f: &mut Formatter) -> Result { + String::fmt(if *self { "true" } else { "false" }, f) + } +} + +#[cfg(stage0)] +//NOTE(stage0): remove impl after snapshot +impl Show for str { + fn fmt(&self, f: &mut Formatter) -> Result { + String::fmt(self, f) + } +} + +#[cfg(not(stage0))] +//NOTE(stage0): remove cfg after snapshot impl Show for str { + fn fmt(&self, f: &mut Formatter) -> Result { + try!(write!(f, "\"")); + for c in self.chars().flat_map(|c| c.escape_default()) { + try!(write!(f, "{}", c)); + } + write!(f, "\"") + } +} + +impl String for str { fn fmt(&self, f: &mut Formatter) -> Result { f.pad(self) } } +#[cfg(stage0)] +//NOTE(stage0): remove impl after snapshot +impl Show for char { + fn fmt(&self, f: &mut Formatter) -> Result { + String::fmt(self, f) + } +} + +#[cfg(not(stage0))] +//NOTE(stage0): remove cfg after snapshot impl Show for char { fn fmt(&self, f: &mut Formatter) -> Result { use char::CharExt; + try!(write!(f, "'")); + for c in self.escape_default() { + try!(write!(f, "{}", c)); + } + write!(f, "'") + } +} +impl String for char { + fn fmt(&self, f: &mut Formatter) -> Result { let mut utf8 = [0u8; 4]; let amt = self.encode_utf8(&mut utf8).unwrap_or(0); let s: &str = unsafe { mem::transmute(utf8[..amt]) }; - Show::fmt(s, f) + f.write_str(s) } } @@ -653,7 +723,15 @@ impl<'a, T> Pointer for &'a mut T { } macro_rules! floating { ($ty:ident) => { + impl Show for $ty { + fn fmt(&self, fmt: &mut Formatter) -> Result { + try!(String::fmt(self, fmt)); + fmt.write_str(stringify!($ty)) + } + } + + impl String for $ty { fn fmt(&self, fmt: &mut Formatter) -> Result { use num::Float; @@ -746,7 +824,7 @@ macro_rules! tuple { if n > 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}", *$name)); + try!(write!(f, "{:?}", *$name)); n += 1; )* if n == 1 { @@ -777,7 +855,7 @@ impl Show for [T] { } else { try!(write!(f, ", ")); } - try!(write!(f, "{}", *x)) + try!(write!(f, "{:?}", *x)) } if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { try!(write!(f, "]")); @@ -786,6 +864,21 @@ impl Show for [T] { } } +impl String for [T] { + fn fmt(&self, f: &mut Formatter) -> Result { + let mut is_first = true; + for x in self.iter() { + if is_first { + is_first = false; + } else { + try!(write!(f, ", ")); + } + try!(String::fmt(x, f)) + } + Ok(()) + } +} + impl Show for () { fn fmt(&self, f: &mut Formatter) -> Result { f.pad("()") @@ -794,23 +887,33 @@ impl Show for () { impl Show for Cell { fn fmt(&self, f: &mut Formatter) -> Result { - write!(f, "Cell {{ value: {} }}", self.get()) + write!(f, "Cell {{ value: {:?} }}", self.get()) + } +} + +#[unstable] +impl Show for RefCell { + fn fmt(&self, f: &mut Formatter) -> Result { + match self.try_borrow() { + Some(val) => write!(f, "RefCell {{ value: {:?} }}", val), + None => write!(f, "RefCell {{ }}") + } } } impl<'b, T: Show> Show for Ref<'b, T> { fn fmt(&self, f: &mut Formatter) -> Result { - (**self).fmt(f) + Show::fmt(&**self, f) } } impl<'b, T: Show> Show for RefMut<'b, T> { fn fmt(&self, f: &mut Formatter) -> Result { - (*(self.deref())).fmt(f) + Show::fmt(&*(self.deref()), f) } } -impl Show for Utf8Error { +impl String for Utf8Error { fn fmt(&self, f: &mut Formatter) -> Result { match *self { Utf8Error::InvalidByte(n) => { diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index e0724fc2da5f5..8405bdf039311 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -153,8 +153,22 @@ pub fn radix(x: T, base: u8) -> RadixFmt { } macro_rules! radix_fmt { - ($T:ty as $U:ty, $fmt:ident) => { + ($T:ty as $U:ty, $fmt:ident, $S:expr) => { + #[cfg(stage0)] impl fmt::Show for RadixFmt<$T, Radix> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } + } + + #[cfg(not(stage0))] + impl fmt::Show for RadixFmt<$T, Radix> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + try!(fmt::String::fmt(self, f)); + f.write_str($S) + } + } + impl fmt::String for RadixFmt<$T, Radix> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) } } @@ -170,24 +184,48 @@ macro_rules! int_base { } } } + +macro_rules! show { + ($T:ident with $S:expr) => { + #[cfg(stage0)] + impl fmt::Show for $T { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } + } + + #[cfg(not(stage0))] + impl fmt::Show for $T { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + try!(fmt::String::fmt(self, f)); + f.write_str($S) + } + } + } +} macro_rules! integer { ($Int:ident, $Uint:ident) => { - int_base! { Show for $Int as $Int -> Decimal } + integer! { $Int, $Uint, stringify!($Int), stringify!($Uint) } + }; + ($Int:ident, $Uint:ident, $SI:expr, $SU:expr) => { + int_base! { String for $Int as $Int -> Decimal } int_base! { Binary for $Int as $Uint -> Binary } int_base! { Octal for $Int as $Uint -> Octal } int_base! { LowerHex for $Int as $Uint -> LowerHex } int_base! { UpperHex for $Int as $Uint -> UpperHex } - radix_fmt! { $Int as $Int, fmt_int } + radix_fmt! { $Int as $Int, fmt_int, $SI } + show! { $Int with $SI } - int_base! { Show for $Uint as $Uint -> Decimal } + int_base! { String for $Uint as $Uint -> Decimal } int_base! { Binary for $Uint as $Uint -> Binary } int_base! { Octal for $Uint as $Uint -> Octal } int_base! { LowerHex for $Uint as $Uint -> LowerHex } int_base! { UpperHex for $Uint as $Uint -> UpperHex } - radix_fmt! { $Uint as $Uint, fmt_int } + radix_fmt! { $Uint as $Uint, fmt_int, $SU } + show! { $Uint with $SU } } } -integer! { int, uint } +integer! { int, uint, "i", "u" } integer! { i8, u8 } integer! { i16, u16 } integer! { i32, u32 } diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index a579f9db4161c..99e49cc21ed5f 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -83,7 +83,7 @@ macro_rules! assert_eq { if !((*left_val == *right_val) && (*right_val == *left_val)) { panic!("assertion failed: `(left == right) && (right == left)` \ - (left: `{}`, right: `{}`)", *left_val, *right_val) + (left: `{:?}`, right: `{:?}`)", *left_val, *right_val) } } } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 8e9bf5487e3ed..95ae6ebfb68c3 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -47,10 +47,10 @@ //! let version = parse_version(&[1, 2, 3, 4]); //! match version { //! Ok(v) => { -//! println!("working with version: {}", v); +//! println!("working with version: {:?}", v); //! } //! Err(e) => { -//! println!("error parsing header: {}", e); +//! println!("error parsing header: {:?}", e); //! } //! } //! ``` @@ -743,7 +743,7 @@ impl Result { match self { Ok(t) => t, Err(e) => - panic!("called `Result::unwrap()` on an `Err` value: {}", e) + panic!("called `Result::unwrap()` on an `Err` value: {:?}", e) } } } @@ -773,7 +773,7 @@ impl Result { pub fn unwrap_err(self) -> E { match self { Ok(t) => - panic!("called `Result::unwrap_err()` on an `Ok` value: {}", t), + panic!("called `Result::unwrap_err()` on an `Ok` value: {:?}", t), Err(e) => e } } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a39787b8207b5..fb3675bf446b1 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -143,7 +143,7 @@ Section: Creating a string */ /// Errors which can occur when attempting to interpret a byte slice as a `str`. -#[derive(Copy, Eq, PartialEq, Clone)] +#[derive(Copy, Eq, PartialEq, Clone, Show)] #[unstable = "error enumeration recently added and definitions may be refined"] pub enum Utf8Error { /// An invalid byte was detected at the byte offset given. diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs index 9b0471bfad936..c0be3a287940a 100644 --- a/src/libcoretest/any.rs +++ b/src/libcoretest/any.rs @@ -56,12 +56,12 @@ fn any_downcast_ref() { match a.downcast_ref::() { Some(&5) => {} - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match a.downcast_ref::() { None => {} - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } } @@ -79,7 +79,7 @@ fn any_downcast_mut() { assert_eq!(*x, 5u); *x = 612; } - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match b_r.downcast_mut::() { @@ -87,27 +87,27 @@ fn any_downcast_mut() { assert_eq!(*x, 7u); *x = 413; } - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match a_r.downcast_mut::() { None => (), - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match b_r.downcast_mut::() { None => (), - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match a_r.downcast_mut::() { Some(&612) => {} - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } match b_r.downcast_mut::() { Some(&413) => {} - x => panic!("Unexpected value {}", x) + x => panic!("Unexpected value {:?}", x) } } diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs index 54da6264bb049..86f34ecd15efe 100644 --- a/src/libcoretest/cell.rs +++ b/src/libcoretest/cell.rs @@ -29,10 +29,10 @@ fn smoketest_cell() { #[test] fn cell_has_sensible_show() { let x = Cell::new("foo bar"); - assert!(format!("{}", x).contains(x.get())); + assert!(format!("{:?}", x).contains(x.get())); x.set("baz qux"); - assert!(format!("{}", x).contains(x.get())); + assert!(format!("{:?}", x).contains(x.get())); } #[test] @@ -40,11 +40,11 @@ fn ref_and_refmut_have_sensible_show() { let refcell = RefCell::new("foo"); let refcell_refmut = refcell.borrow_mut(); - assert!(format!("{}", refcell_refmut).contains("foo")); + assert!(format!("{:?}", refcell_refmut).contains("foo")); drop(refcell_refmut); let refcell_ref = refcell.borrow(); - assert!(format!("{}", refcell_ref).contains("foo")); + assert!(format!("{:?}", refcell_ref).contains("foo")); drop(refcell_ref); } diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs index 1e28933becd6e..c259e4cbb686d 100644 --- a/src/libcoretest/fmt/num.rs +++ b/src/libcoretest/fmt/num.rs @@ -26,6 +26,11 @@ fn test_format_int() { assert!(format!("{}", -1i16) == "-1"); assert!(format!("{}", -1i32) == "-1"); assert!(format!("{}", -1i64) == "-1"); + assert!(format!("{:?}", 1i) == "1i"); + assert!(format!("{:?}", 1i8) == "1i8"); + assert!(format!("{:?}", 1i16) == "1i16"); + assert!(format!("{:?}", 1i32) == "1i32"); + assert!(format!("{:?}", 1i64) == "1i64"); assert!(format!("{:b}", 1i) == "1"); assert!(format!("{:b}", 1i8) == "1"); assert!(format!("{:b}", 1i16) == "1"); @@ -52,6 +57,11 @@ fn test_format_int() { assert!(format!("{}", 1u16) == "1"); assert!(format!("{}", 1u32) == "1"); assert!(format!("{}", 1u64) == "1"); + assert!(format!("{:?}", 1u) == "1u"); + assert!(format!("{:?}", 1u8) == "1u8"); + assert!(format!("{:?}", 1u16) == "1u16"); + assert!(format!("{:?}", 1u32) == "1u32"); + assert!(format!("{:?}", 1u64) == "1u64"); assert!(format!("{:b}", 1u) == "1"); assert!(format!("{:b}", 1u8) == "1"); assert!(format!("{:b}", 1u16) == "1"); @@ -84,12 +94,14 @@ fn test_format_int() { #[test] fn test_format_int_zero() { assert!(format!("{}", 0i) == "0"); + assert!(format!("{:?}", 0i) == "0i"); assert!(format!("{:b}", 0i) == "0"); assert!(format!("{:o}", 0i) == "0"); assert!(format!("{:x}", 0i) == "0"); assert!(format!("{:X}", 0i) == "0"); assert!(format!("{}", 0u) == "0"); + assert!(format!("{:?}", 0u) == "0u"); assert!(format!("{:b}", 0u) == "0"); assert!(format!("{:o}", 0u) == "0"); assert!(format!("{:x}", 0u) == "0"); @@ -183,6 +195,12 @@ mod uint { b.iter(|| { format!("{:x}", rng.gen::()); }) } + #[bench] + fn format_show(b: &mut Bencher) { + let mut rng = weak_rng(); + b.iter(|| { format!("{:?}", rng.gen::()); }) + } + #[bench] fn format_base_36(b: &mut Bencher) { let mut rng = weak_rng(); @@ -219,6 +237,12 @@ mod int { b.iter(|| { format!("{:x}", rng.gen::()); }) } + #[bench] + fn format_show(b: &mut Bencher) { + let mut rng = weak_rng(); + b.iter(|| { format!("{:?}", rng.gen::()); }) + } + #[bench] fn format_base_36(b: &mut Bencher) { let mut rng = weak_rng(); diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs index 52ea14dd05dd9..b9403598ec2b2 100644 --- a/src/libcoretest/result.rs +++ b/src/libcoretest/result.rs @@ -95,10 +95,10 @@ pub fn test_fmt_default() { let ok: Result = Ok(100); let err: Result = Err("Err"); - let s = format!("{}", ok); - assert_eq!(s, "Ok(100)"); - let s = format!("{}", err); - assert_eq!(s, "Err(Err)"); + let s = format!("{:?}", ok); + assert_eq!(s, "Ok(100i)"); + let s = format!("{:?}", err); + assert_eq!(s, "Err(\"Err\")"); } #[test] diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs index c3bc38a6614b8..62eb9f4ad3480 100644 --- a/src/libcoretest/tuple.rs +++ b/src/libcoretest/tuple.rs @@ -59,10 +59,10 @@ fn test_tuple_cmp() { #[test] fn test_show() { - let s = format!("{}", (1i,)); - assert_eq!(s, "(1,)"); - let s = format!("{}", (1i, true)); - assert_eq!(s, "(1, true)"); - let s = format!("{}", (1i, "hi", true)); - assert_eq!(s, "(1, hi, true)"); + let s = format!("{:?}", (1i,)); + assert_eq!(s, "(1i,)"); + let s = format!("{:?}", (1i, true)); + assert_eq!(s, "(1i, true)"); + let s = format!("{:?}", (1i, "hi", true)); + assert_eq!(s, "(1i, \"hi\", true)"); } diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 917c6e99992f2..2edbaff99716c 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -212,12 +212,12 @@ impl<'a> Parser<'a> { self.cur.next(); } Some((_, other)) => { - self.err(format!("expected `{}`, found `{}`", c, other)[]); + self.err(format!("expected `{:?}`, found `{:?}`", c, other)[]); } None => { - self.err(format!("expected `{}` but string was terminated", + self.err(format!("expected `{:?}` but string was terminated", c)[]); - } + } } } diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 18077795e245f..52d33d94109eb 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -105,7 +105,7 @@ use std::iter::repeat; use std::result; /// Name of an option. Either a string or a single char. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] pub enum Name { /// A string representing the long name of an option. /// For example: "help" @@ -116,7 +116,7 @@ pub enum Name { } /// Describes whether an option has an argument. -#[derive(Clone, Copy, PartialEq, Eq)] +#[derive(Clone, Copy, PartialEq, Eq, Show)] pub enum HasArg { /// The option requires an argument. Yes, @@ -127,7 +127,7 @@ pub enum HasArg { } /// Describes how often an option may occur. -#[derive(Clone, Copy, PartialEq, Eq)] +#[derive(Clone, Copy, PartialEq, Eq, Show)] pub enum Occur { /// The option occurs once. Req, @@ -138,7 +138,7 @@ pub enum Occur { } /// A description of a possible option. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] pub struct Opt { /// Name of the option pub name: Name, @@ -152,7 +152,7 @@ pub struct Opt { /// One group of options, e.g., both `-h` and `--help`, along with /// their shared description and properties. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] pub struct OptGroup { /// Short name of the option, e.g. `h` for a `-h` option pub short_name: String, @@ -169,7 +169,7 @@ pub struct OptGroup { } /// Describes whether an option is given at all or has a value. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] enum Optval { Val(String), Given, @@ -177,7 +177,7 @@ enum Optval { /// The result of checking command line arguments. Contains a vector /// of matches and a vector of free strings. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] pub struct Matches { /// Options that matched opts: Vec, @@ -190,7 +190,7 @@ pub struct Matches { /// The type returned when the command line does not conform to the /// expected format. Use the `Show` implementation to output detailed /// information. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Show)] pub enum Fail { /// The option requires an argument but none was passed. ArgumentMissing(String), @@ -205,7 +205,7 @@ pub enum Fail { } /// The type of failure that occurred. -#[derive(Copy, PartialEq, Eq)] +#[derive(Copy, PartialEq, Eq, Show)] #[allow(missing_docs)] pub enum FailType { ArgumentMissing_, @@ -536,13 +536,13 @@ pub fn opt(short_name: &str, impl Fail { /// Convert a `Fail` enum into an error string. - #[deprecated="use `Show` (`{}` format specifier)"] + #[deprecated="use `fmt::String` (`{}` format specifier)"] pub fn to_err_msg(self) -> String { self.to_string() } } -impl fmt::Show for Fail { +impl fmt::String for Fail { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { ArgumentMissing(ref nm) => { diff --git a/src/liblog/directive.rs b/src/liblog/directive.rs index 8134503019c99..d741019aa7b9c 100644 --- a/src/liblog/directive.rs +++ b/src/liblog/directive.rs @@ -84,7 +84,7 @@ pub fn parse_logging_spec(spec: &str) -> (Vec, Option) { match Regex::new(filter) { Ok(re) => Some(re), Err(e) => { - println!("warning: invalid regex filter - {}", e); + println!("warning: invalid regex filter - {:?}", e); None } } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index df85e89efd17c..fac686ca6c1bd 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -16,12 +16,12 @@ //! #[macro_use] extern crate log; //! //! fn main() { -//! debug!("this is a debug {}", "message"); +//! debug!("this is a debug {:?}", "message"); //! error!("this is printed by default"); //! //! if log_enabled!(log::INFO) { //! let x = 3i * 4i; // expensive computation -//! info!("the answer was: {}", x); +//! info!("the answer was: {:?}", x); //! } //! } //! ``` @@ -238,11 +238,17 @@ struct DefaultLogger { pub struct LogLevel(pub u32); impl fmt::Show for LogLevel { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, fmt) + } +} + +impl fmt::String for LogLevel { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let LogLevel(level) = *self; match LOG_LEVEL_NAMES.get(level as uint - 1) { - Some(name) => name.fmt(fmt), - None => level.fmt(fmt) + Some(ref name) => fmt::String::fmt(name, fmt), + None => fmt::String::fmt(&level, fmt) } } } @@ -254,7 +260,7 @@ impl Logger for DefaultLogger { record.level, record.module_path, record.args) { - Err(e) => panic!("failed to log: {}", e), + Err(e) => panic!("failed to log: {:?}", e), Ok(()) => {} } } @@ -264,7 +270,7 @@ impl Drop for DefaultLogger { fn drop(&mut self) { // FIXME(#12628): is panicking the right thing to do? match self.handle.flush() { - Err(e) => panic!("failed to flush a logger: {}", e), + Err(e) => panic!("failed to flush a logger: {:?}", e), Ok(()) => {} } } diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index e57542a6d14de..301d3444eccfb 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -147,7 +147,7 @@ pub mod reader { match $e { Ok(e) => e, Err(e) => { - debug!("ignored error: {}", e); + debug!("ignored error: {:?}", e); return $r } } @@ -256,7 +256,7 @@ pub mod reader { match maybe_get_doc(d, tg) { Some(d) => d, None => { - error!("failed to find block with tag {}", tg); + error!("failed to find block with tag {:?}", tg); panic!(); } } @@ -351,8 +351,8 @@ pub mod reader { self.pos = r_doc.end; let str = r_doc.as_str_slice(); if lbl != str { - return Err(Expected(format!("Expected label {} but \ - found {}", lbl, str))); + return Err(Expected(format!("Expected label {:?} but \ + found {:?}", lbl, str))); } } } @@ -360,14 +360,14 @@ pub mod reader { } fn next_doc(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult> { - debug!(". next_doc(exp_tag={})", exp_tag); + debug!(". next_doc(exp_tag={:?})", exp_tag); if self.pos >= self.parent.end { return Err(Expected(format!("no more documents in \ current node!"))); } let TaggedDoc { tag: r_tag, doc: r_doc } = try!(doc_at(self.parent.data, self.pos)); - debug!("self.parent={}-{} self.pos={} r_tag={} r_doc={}-{}", + debug!("self.parent={:?}-{:?} self.pos={:?} r_tag={:?} r_doc={:?}-{:?}", self.parent.start, self.parent.end, self.pos, @@ -375,8 +375,8 @@ pub mod reader { r_doc.start, r_doc.end); if r_tag != (exp_tag as uint) { - return Err(Expected(format!("expected EBML doc with tag {} but \ - found tag {}", exp_tag, r_tag))); + return Err(Expected(format!("expected EBML doc with tag {:?} but \ + found tag {:?}", exp_tag, r_tag))); } if r_doc.end > self.parent.end { return Err(Expected(format!("invalid EBML, child extends to \ @@ -403,7 +403,7 @@ pub mod reader { fn _next_uint(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult { let r = doc_as_u32(try!(self.next_doc(exp_tag))); - debug!("_next_uint exp_tag={} result={}", exp_tag, r); + debug!("_next_uint exp_tag={:?} result={:?}", exp_tag, r); Ok(r as uint) } @@ -486,7 +486,7 @@ pub mod reader { fn read_enum(&mut self, name: &str, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_enum({})", name); + debug!("read_enum({:?})", name); try!(self._check_label(name)); let doc = try!(self.next_doc(EsEnum)); @@ -508,7 +508,7 @@ pub mod reader { { debug!("read_enum_variant()"); let idx = try!(self._next_uint(EsEnumVid)); - debug!(" idx={}", idx); + debug!(" idx={:?}", idx); let doc = try!(self.next_doc(EsEnumBody)); @@ -526,7 +526,7 @@ pub mod reader { fn read_enum_variant_arg(&mut self, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_enum_variant_arg(idx={})", idx); + debug!("read_enum_variant_arg(idx={:?})", idx); f(self) } @@ -536,7 +536,7 @@ pub mod reader { { debug!("read_enum_struct_variant()"); let idx = try!(self._next_uint(EsEnumVid)); - debug!(" idx={}", idx); + debug!(" idx={:?}", idx); let doc = try!(self.next_doc(EsEnumBody)); @@ -558,21 +558,21 @@ pub mod reader { -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_enum_struct_variant_arg(name={}, idx={})", name, idx); + debug!("read_enum_struct_variant_arg(name={:?}, idx={:?})", name, idx); f(self) } fn read_struct(&mut self, name: &str, _: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_struct(name={})", name); + debug!("read_struct(name={:?})", name); f(self) } fn read_struct_field(&mut self, name: &str, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_struct_field(name={}, idx={})", name, idx); + debug!("read_struct_field(name={:?}, idx={:?})", name, idx); try!(self._check_label(name)); f(self) } @@ -594,14 +594,14 @@ pub mod reader { fn read_tuple_arg(&mut self, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_tuple_arg(idx={})", idx); + debug!("read_tuple_arg(idx={:?})", idx); self.read_seq_elt(idx, f) } fn read_tuple_struct(&mut self, name: &str, len: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_tuple_struct(name={})", name); + debug!("read_tuple_struct(name={:?})", name); self.read_tuple(len, f) } @@ -611,7 +611,7 @@ pub mod reader { -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_tuple_struct_arg(idx={})", idx); + debug!("read_tuple_struct_arg(idx={:?})", idx); self.read_tuple_arg(idx, f) } @@ -638,7 +638,7 @@ pub mod reader { debug!("read_seq()"); self.push_doc(EsVec, move |d| { let len = try!(d._next_uint(EsVecLen)); - debug!(" len={}", len); + debug!(" len={:?}", len); f(d, len) }) } @@ -646,7 +646,7 @@ pub mod reader { fn read_seq_elt(&mut self, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_seq_elt(idx={})", idx); + debug!("read_seq_elt(idx={:?})", idx); self.push_doc(EsVecElt, f) } @@ -656,7 +656,7 @@ pub mod reader { debug!("read_map()"); self.push_doc(EsMap, move |d| { let len = try!(d._next_uint(EsMapLen)); - debug!(" len={}", len); + debug!(" len={:?}", len); f(d, len) }) } @@ -664,14 +664,14 @@ pub mod reader { fn read_map_elt_key(&mut self, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_map_elt_key(idx={})", idx); + debug!("read_map_elt_key(idx={:?})", idx); self.push_doc(EsMapKey, f) } fn read_map_elt_val(&mut self, idx: uint, f: F) -> DecodeResult where F: FnOnce(&mut Decoder<'doc>) -> DecodeResult, { - debug!("read_map_elt_val(idx={})", idx); + debug!("read_map_elt_val(idx={:?})", idx); self.push_doc(EsMapVal, f) } @@ -1007,7 +1007,7 @@ pub mod writer { } pub fn start_tag(&mut self, tag_id: uint) -> EncodeResult { - debug!("Start tag {}", tag_id); + debug!("Start tag {:?}", tag_id); // Write the enum ID: try!(write_vuint(self.writer, tag_id)); @@ -1026,7 +1026,7 @@ pub mod writer { try!(write_sized_vuint(self.writer, size, 4u)); let r = try!(self.writer.seek(cur_pos as i64, io::SeekSet)); - debug!("End tag (size = {})", size); + debug!("End tag (size = {:?})", size); Ok(r) } @@ -1093,12 +1093,12 @@ pub mod writer { } pub fn wr_bytes(&mut self, b: &[u8]) -> EncodeResult { - debug!("Write {} bytes", b.len()); + debug!("Write {:?} bytes", b.len()); self.writer.write(b) } pub fn wr_str(&mut self, s: &str) -> EncodeResult { - debug!("Write str: {}", s); + debug!("Write str: {:?}", s); self.writer.write(s.as_bytes()) } } @@ -1608,7 +1608,7 @@ mod tests { #[test] fn test_option_int() { fn test_v(v: Option) { - debug!("v == {}", v); + debug!("v == {:?}", v); let mut wr = SeekableMemWriter::new(); { let mut rbml_w = writer::Encoder::new(&mut wr); @@ -1617,7 +1617,7 @@ mod tests { let rbml_doc = Doc::new(wr.get_ref()); let mut deser = reader::Decoder::new(rbml_doc); let v1 = Decodable::decode(&mut deser).unwrap(); - debug!("v1 == {}", v1); + debug!("v1 == {:?}", v1); assert_eq!(v, v1); } diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index 0084be49b5619..92ed048bae0db 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -13,7 +13,6 @@ //! Regular expressions implemented in Rust //! //! For official documentation, see the rust-lang/regex crate - #![crate_name = "regex"] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index 07da86afcc971..943f8a5fec2eb 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -39,7 +39,7 @@ pub struct Error { impl fmt::Show for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Regex syntax error near position {}: {}", + write!(f, "Regex syntax error near position {}: {:?}", self.pos, self.msg) } } @@ -121,7 +121,7 @@ impl BuildAst { fn flags(&self) -> Flags { match *self { Paren(flags, _, _) => flags, - _ => panic!("Cannot get flags from {}", self), + _ => panic!("Cannot get flags from {:?}", self), } } @@ -129,7 +129,7 @@ impl BuildAst { match *self { Paren(_, 0, _) => None, Paren(_, c, _) => Some(c), - _ => panic!("Cannot get capture group from {}", self), + _ => panic!("Cannot get capture group from {:?}", self), } } @@ -143,7 +143,7 @@ impl BuildAst { Some(name.clone()) } } - _ => panic!("Cannot get capture name from {}", self), + _ => panic!("Cannot get capture name from {:?}", self), } } @@ -157,7 +157,7 @@ impl BuildAst { fn unwrap(self) -> Result { match self { Expr(x) => Ok(x), - _ => panic!("Tried to unwrap non-AST item: {}", self), + _ => panic!("Tried to unwrap non-AST item: {:?}", self), } } } @@ -284,7 +284,7 @@ impl<'a> Parser<'a> { match self.next_char() { true => Ok(()), false => { - self.err(format!("Expected {} but got EOF.", + self.err(format!("Expected {:?} but got EOF.", expected)[]) } } @@ -293,10 +293,10 @@ impl<'a> Parser<'a> { fn expect(&mut self, expected: char) -> Result<(), Error> { match self.next_char() { true if self.cur() == expected => Ok(()), - true => self.err(format!("Expected '{}' but got '{}'.", + true => self.err(format!("Expected '{:?}' but got '{:?}'.", expected, self.cur())[]), false => { - self.err(format!("Expected '{}' but got EOF.", + self.err(format!("Expected '{:?}' but got EOF.", expected)[]) } } @@ -394,7 +394,7 @@ impl<'a> Parser<'a> { continue } Some(ast) => - panic!("Expected Class AST but got '{}'", ast), + panic!("Expected Class AST but got '{:?}'", ast), // Just drop down and try to add as a regular character. None => {}, }, @@ -409,7 +409,7 @@ impl<'a> Parser<'a> { return self.err( "\\A, \\z, \\b and \\B are not valid escape \ sequences inside a character class."), - ast => panic!("Unexpected AST item '{}'", ast), + ast => panic!("Unexpected AST item '{:?}'", ast), } } ']' if ranges.len() > 0 || alts.len() > 0 => { @@ -442,7 +442,7 @@ impl<'a> Parser<'a> { match try!(self.parse_escape()) { Literal(c3, _) => c2 = c3, // allow literal escapes below ast => - return self.err(format!("Expected a literal, but got {}.", + return self.err(format!("Expected a literal, but got {:?}.", ast)[]), } } @@ -512,7 +512,7 @@ impl<'a> Parser<'a> { None => { return self.err(format!("No closing brace for counted \ repetition starting at position \ - {}.", + {:?}.", start)[]) } }; @@ -685,7 +685,7 @@ impl<'a> Parser<'a> { match num::from_str_radix::(s[], 8) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => { - self.err(format!("Could not parse '{}' as octal number.", + self.err(format!("Could not parse {:?} as octal number.", s)[]) } } diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 1840a3343e63c..57f9defc0a188 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -90,10 +90,19 @@ impl Clone for ExNative { } } +#[cfg(stage0)] +//FIXME: remove after stage0 snapshot impl fmt::Show for Regex { /// Shows the original regular expression. fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.as_str()) + fmt::String::fmt(self.as_str(), f) + } +} + +impl fmt::String for Regex { + /// Shows the original regular expression. + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self.as_str(), f) } } diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 425e34cd9f042..887c306c39ce0 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1629,7 +1629,6 @@ declare_lint! { Warn, "detects use of #[deprecated] items" } - // FIXME #6875: Change to Warn after std library stabilization is complete declare_lint! { EXPERIMENTAL, @@ -1848,7 +1847,7 @@ declare_lint! { "detects transmutes of fat pointers" } -declare_lint!{ +declare_lint! { pub MISSING_COPY_IMPLEMENTATIONS, Warn, "detects potentially-forgotten implementations of `Copy`" diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 1401a7d4a1a6e..0a2f45e536209 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -246,13 +246,13 @@ pub fn get_field_type<'tcx>(tcx: &ty::ctxt<'tcx>, class_id: ast::DefId, let class_doc = expect(tcx.sess.diagnostic(), decoder::maybe_find_item(class_id.node, all_items), || { - (format!("get_field_type: class ID {} not found", + (format!("get_field_type: class ID {:?} not found", class_id)).to_string() }); let the_field = expect(tcx.sess.diagnostic(), decoder::maybe_find_item(def.node, class_doc), || { - (format!("get_field_type: in class {}, field ID {} not found", + (format!("get_field_type: in class {:?}, field ID {:?} not found", class_id, def)).to_string() }); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index e4226ddde85b6..3fac98ee405a3 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -845,7 +845,7 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, parent_id: NodeId, ast_item_opt: Option<&ast::ImplItem>) { - debug!("encode_info_for_method: {} {}", m.def_id, + debug!("encode_info_for_method: {:?} {:?}", m.def_id, token::get_name(m.name)); rbml_w.start_tag(tag_items_data_item); @@ -887,7 +887,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext, impl_path: PathElems, parent_id: NodeId, typedef_opt: Option>) { - debug!("encode_info_for_associated_type({},{})", + debug!("encode_info_for_associated_type({:?},{:?})", associated_type.def_id, token::get_name(associated_type.name)); diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 07dc13ff0d48f..ddb592f11efac 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -738,12 +738,12 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId { let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| s.parse::()) { Some(cn) => cn as ast::CrateNum, - None => panic!("internal error: parse_def_id: crate number expected, found {}", + None => panic!("internal error: parse_def_id: crate number expected, found {:?}", crate_part) }; let def_num = match str::from_utf8(def_part).ok().and_then(|s| s.parse::()) { Some(dn) => dn as ast::NodeId, - None => panic!("internal error: parse_def_id: id expected, found {}", + None => panic!("internal error: parse_def_id: id expected, found {:?}", def_part) }; ast::DefId { krate: crate_num, node: def_num } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 93a19a01f668f..69dfab1e5c1ac 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -82,7 +82,7 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext, e::IIImplItemRef(_, &ast::MethodImplItem(ref m)) => m.id, e::IIImplItemRef(_, &ast::TypeImplItem(ref ti)) => ti.id, }; - debug!("> Encoding inlined item: {} ({})", + debug!("> Encoding inlined item: {} ({:?})", ecx.tcx.map.path_to_string(id), rbml_w.writer.tell()); @@ -96,7 +96,7 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext, encode_side_tables_for_ii(ecx, rbml_w, &ii); rbml_w.end_tag(); - debug!("< Encoded inlined fn: {} ({})", + debug!("< Encoded inlined fn: {} ({:?})", ecx.tcx.map.path_to_string(id), rbml_w.writer.tell()); } @@ -127,7 +127,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata, None => Err(path), Some(ast_doc) => { let mut path_as_str = None; - debug!("> Decoding inlined fn: {}::?", + debug!("> Decoding inlined fn: {:?}::?", { // Do an Option dance to use the path after it is moved below. let s = ast_map::path_to_string(ast_map::Values(path.iter())); @@ -1880,7 +1880,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did), TypeParameter | UnboxedClosureSource => dcx.tr_intern_def_id(did) }; - debug!("convert_def_id(source={}, did={})={}", source, did, r); + debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r); return r; } } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 3c672d0fdb6fa..1f8f3cde06911 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -480,12 +480,12 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let inputs = inline_asm.inputs.iter(); let outputs = inline_asm.outputs.iter(); let post_inputs = self.exprs(inputs.map(|a| { - debug!("cfg::construct InlineAsm id:{} input:{}", expr.id, a); + debug!("cfg::construct InlineAsm id:{} input:{:?}", expr.id, a); let &(_, ref expr) = a; &**expr }), pred); let post_outputs = self.exprs(outputs.map(|a| { - debug!("cfg::construct InlineAsm id:{} output:{}", expr.id, a); + debug!("cfg::construct InlineAsm id:{} output:{:?}", expr.id, a); let &(_, ref expr, _) = a; &**expr }), post_inputs); @@ -622,7 +622,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { r => { self.tcx.sess.span_bug( expr.span, - format!("bad entry `{}` in def_map for label", + format!("bad entry `{:?}` in def_map for label", r)[]); } } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index ac53bdbefcf10..621d7274b3f7c 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -118,7 +118,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) { DefStruct(_) | DefVariant(_, _, _) => {} def => { - debug!("(checking const) found bad def: {}", def); + debug!("(checking const) found bad def: {:?}", def); span_err!(v.tcx.sess, e.span, E0014, "paths in constants may only refer to constants \ or functions"); diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index f2b9ecb5ec432..1b530ec08861e 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -574,7 +574,7 @@ fn is_useful(cx: &MatchCheckCtxt, witness: WitnessPreference) -> Usefulness { let &Matrix(ref rows) = matrix; - debug!("{:}", matrix); + debug!("{:?}", matrix); if rows.len() == 0u { return match witness { ConstructWitness => UsefulWithWitness(vec!()), @@ -1042,7 +1042,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, cx.tcx.sess.span_bug( p.span, format!("binding pattern {} is not an \ - identifier: {}", + identifier: {:?}", p.id, p.node)[]); } diff --git a/src/librustc/middle/check_rvalues.rs b/src/librustc/middle/check_rvalues.rs index c383b1579ef84..5ff1f36f0e06a 100644 --- a/src/librustc/middle/check_rvalues.rs +++ b/src/librustc/middle/check_rvalues.rs @@ -59,7 +59,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for RvalueContextDelegate<'a, 'tcx> { span: Span, cmt: mc::cmt<'tcx>, _: euv::ConsumeMode) { - debug!("consume; cmt: {}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty)); + debug!("consume; cmt: {:?}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty)); if !ty::type_is_sized(self.param_env, span, cmt.ty) { span_err!(self.tcx.sess, span, E0161, "cannot move a value of type {0}: the size of {0} cannot be statically determined", diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index e78b8047f6958..7a67f0171bfd7 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -196,7 +196,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let words_per_id = (bits_per_id + uint::BITS - 1) / uint::BITS; let num_nodes = cfg.graph.all_nodes().len(); - debug!("DataFlowContext::new(analysis_name: {}, id_range={}, \ + debug!("DataFlowContext::new(analysis_name: {}, id_range={:?}, \ bits_per_id={}, words_per_id={}) \ num_nodes: {}", analysis_name, id_range, bits_per_id, words_per_id, @@ -251,7 +251,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [uint]) { //! Applies the gen and kill sets for `cfgidx` to `bits` - debug!("{} apply_gen_kill(cfgidx={}, bits={}) [before]", + debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [before]", self.analysis_name, cfgidx, mut_bits_to_string(bits)); assert!(self.bits_per_id > 0); @@ -261,7 +261,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let kills = self.kills.slice(start, end); bitwise(bits, kills, &Subtract); - debug!("{} apply_gen_kill(cfgidx={}, bits={}) [after]", + debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [after]", self.analysis_name, cfgidx, mut_bits_to_string(bits)); } @@ -315,7 +315,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { temp_bits[] } }; - debug!("{} each_bit_for_node({}, cfgidx={}) bits={}", + debug!("{} each_bit_for_node({:?}, cfgidx={:?}) bits={}", self.analysis_name, e, cfgidx, bits_to_string(slice)); self.each_bit(slice, f) } @@ -410,7 +410,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { } } None => { - debug!("{} add_kills_from_flow_exits flow_exit={} \ + debug!("{} add_kills_from_flow_exits flow_exit={:?} \ no cfg_idx for exiting_scope={}", self.analysis_name, flow_exit, node_id); } @@ -419,10 +419,10 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { if changed { let bits = self.kills.slice_mut(start, end); - debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [before]", + debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); bits.clone_from_slice(orig_kills[]); - debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [after]", + debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [after]", self.analysis_name, flow_exit, mut_bits_to_string(bits)); } true @@ -481,7 +481,7 @@ impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> { assert!(self.dfcx.bits_per_id > 0); cfg.graph.each_node(|node_index, node| { - debug!("DataFlowContext::walk_cfg idx={} id={} begin in_out={}", + debug!("DataFlowContext::walk_cfg idx={:?} id={} begin in_out={}", node_index, node.data.id, bits_to_string(in_out)); let (start, end) = self.dfcx.compute_id_range(node_index); @@ -521,7 +521,7 @@ impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> { edge: &cfg::CFGEdge) { let source = edge.source(); let cfgidx = edge.target(); - debug!("{} propagate_bits_into_entry_set_for(pred_bits={}, {} to {})", + debug!("{} propagate_bits_into_entry_set_for(pred_bits={}, {:?} to {:?})", self.dfcx.analysis_name, bits_to_string(pred_bits), source, cfgidx); assert!(self.dfcx.bits_per_id > 0); @@ -532,7 +532,7 @@ impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> { bitwise(on_entry, pred_bits, &self.dfcx.oper) }; if changed { - debug!("{} changed entry set for {} to {}", + debug!("{} changed entry set for {:?} to {}", self.dfcx.analysis_name, cfgidx, bits_to_string(self.dfcx.on_entry.slice(start, end))); self.changed = true; diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 6b56ece28bdb2..ef6002d0f121e 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -149,7 +149,7 @@ fn calculate_type(sess: &session::Session, add_library(sess, cnum, cstore::RequireDynamic, &mut formats); let deps = csearch::get_dylib_dependency_formats(&sess.cstore, cnum); for &(depnum, style) in deps.iter() { - debug!("adding {}: {}", style, + debug!("adding {:?}: {}", style, sess.cstore.get_crate_data(depnum).name.clone()); add_library(sess, depnum, style, &mut formats); } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index df2a4e4c2532a..50e3c8056b2f0 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -1035,7 +1035,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { if pat_util::pat_is_binding(def_map, pat) { let tcx = typer.tcx(); - debug!("binding cmt_pat={} pat={} match_mode={}", + debug!("binding cmt_pat={} pat={} match_mode={:?}", cmt_pat.repr(tcx), pat.repr(tcx), match_mode); @@ -1171,7 +1171,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // pattern. if !tcx.sess.has_errors() { - let msg = format!("Pattern has unexpected type: {} and type {}", + let msg = format!("Pattern has unexpected type: {:?} and type {}", def, cmt_pat.ty.repr(tcx)); tcx.sess.span_bug(pat.span, msg[]) @@ -1188,7 +1188,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // reported. if !tcx.sess.has_errors() { - let msg = format!("Pattern has unexpected def: {} and type {}", + let msg = format!("Pattern has unexpected def: {:?} and type {}", def, cmt_pat.ty.repr(tcx)); tcx.sess.span_bug(pat.span, msg[]) diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 52b6af7608170..26cafb3c3d4a3 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -55,7 +55,7 @@ pub struct Edge { impl Show for Edge { fn fmt(&self, f: &mut Formatter) -> Result<(), Error> { - write!(f, "Edge {{ next_edge: [{}, {}], source: {}, target: {}, data: {} }}", + write!(f, "Edge {{ next_edge: [{:?}, {:?}], source: {:?}, target: {:?}, data: {:?} }}", self.next_edge[0], self.next_edge[1], self.source, self.target, self.data) } diff --git a/src/librustc/middle/infer/coercion.rs b/src/librustc/middle/infer/coercion.rs index 65de3a083d2d9..9f87e73d4af9d 100644 --- a/src/librustc/middle/infer/coercion.rs +++ b/src/librustc/middle/infer/coercion.rs @@ -265,7 +265,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { ty::mt{ty: ty, mutbl: mt_b.mutbl}); try!(self.get_ref().infcx.try(|_| sub.tys(ty, b))); debug!("Success, coerced with AutoDerefRef(1, \ - AutoPtr(AutoUnsize({})))", kind); + AutoPtr(AutoUnsize({:?})))", kind); Ok(Some(AdjustDerefRef(AutoDerefRef { autoderefs: 1, autoref: Some(ty::AutoPtr(r_borrow, mt_b.mutbl, @@ -288,7 +288,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { ty::mt{ty: ty, mutbl: mt_b.mutbl}); try!(self.get_ref().infcx.try(|_| sub.tys(ty, b))); debug!("Success, coerced with AutoDerefRef(1, \ - AutoPtr(AutoUnsize({})))", kind); + AutoPtr(AutoUnsize({:?})))", kind); Ok(Some(AdjustDerefRef(AutoDerefRef { autoderefs: 1, autoref: Some(ty::AutoUnsafe(mt_b.mutbl, @@ -306,7 +306,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { let ty = ty::mk_uniq(self.tcx(), ty); try!(self.get_ref().infcx.try(|_| sub.tys(ty, b))); debug!("Success, coerced with AutoDerefRef(1, \ - AutoUnsizeUniq({}))", kind); + AutoUnsizeUniq({:?}))", kind); Ok(Some(AdjustDerefRef(AutoDerefRef { autoderefs: 1, autoref: Some(ty::AutoUnsizeUniq(kind)) @@ -328,7 +328,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { a: Ty<'tcx>, ty_b: Ty<'tcx>) -> Option<(Ty<'tcx>, ty::UnsizeKind<'tcx>)> { - debug!("unsize_ty(a={}, ty_b={})", a, ty_b.repr(self.tcx())); + debug!("unsize_ty(a={:?}, ty_b={})", a, ty_b.repr(self.tcx())); let tcx = self.tcx(); @@ -406,7 +406,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { { let tcx = self.tcx(); - debug!("coerce_borrowed_object(a={}, b={}, b_mutbl={})", + debug!("coerce_borrowed_object(a={}, b={}, b_mutbl={:?})", a.repr(tcx), b.repr(tcx), b_mutbl); @@ -426,7 +426,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { { let tcx = self.tcx(); - debug!("coerce_unsafe_object(a={}, b={}, b_mutbl={})", + debug!("coerce_unsafe_object(a={}, b={}, b_mutbl={:?})", a.repr(tcx), b.repr(tcx), b_mutbl); @@ -449,7 +449,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { match a.sty { ty::ty_rptr(_, ty::mt{ty, mutbl}) => match ty.sty { ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => { - debug!("mutbl={} b_mutbl={}", mutbl, b_mutbl); + debug!("mutbl={:?} b_mutbl={:?}", mutbl, b_mutbl); let tr = ty::mk_trait(tcx, principal.clone(), bounds.clone()); try!(self.subtype(mk_ty(tr), b)); Ok(Some(AdjustDerefRef(AutoDerefRef { diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index dd711fcbf022e..5fca35f88c174 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -361,7 +361,7 @@ pub trait Combine<'tcx> : Sized { a: ty::TraitStore, b: ty::TraitStore) -> cres<'tcx, ty::TraitStore> { - debug!("{}.trait_stores(a={}, b={})", self.tag(), a, b); + debug!("{}.trait_stores(a={:?}, b={:?})", self.tag(), a, b); match (a, b) { (ty::RegionTraitStore(a_r, a_m), @@ -471,7 +471,7 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, let tcx = this.infcx().tcx; let a_sty = &a.sty; let b_sty = &b.sty; - debug!("super_tys: a_sty={} b_sty={}", a_sty, b_sty); + debug!("super_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty); return match (a_sty, b_sty) { // The "subtype" ought to be handling cases involving var: (&ty::ty_infer(TyVar(_)), _) | @@ -550,7 +550,7 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, (&ty::ty_trait(ref a_), &ty::ty_trait(ref b_)) => { - debug!("Trying to match traits {} and {}", a, b); + debug!("Trying to match traits {:?} and {:?}", a, b); let principal = try!(this.binders(&a_.principal, &b_.principal)); let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds)); Ok(ty::mk_trait(tcx, principal, bounds)) @@ -724,7 +724,7 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { Some(e) => e, }; - debug!("instantiate(a_ty={} dir={} b_vid={})", + debug!("instantiate(a_ty={} dir={:?} b_vid={})", a_ty.repr(tcx), dir, b_vid.repr(tcx)); @@ -745,7 +745,7 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { self.generalize(a_ty, b_vid, true) } }); - debug!("instantiate(a_ty={}, dir={}, \ + debug!("instantiate(a_ty={}, dir={:?}, \ b_vid={}, generalized_ty={})", a_ty.repr(tcx), dir, b_vid.repr(tcx), generalized_ty.repr(tcx)); diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index e58ff53b00cb9..ff1afd9919a8e 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -268,7 +268,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { } } let pe = ProcessedErrors(var_origins, trace_origins, same_regions); - debug!("errors processed: {}", pe); + debug!("errors processed: {:?}", pe); processed_errors.push(pe); } return processed_errors; @@ -297,7 +297,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { sub: Region, sup: Region) -> Option { - debug!("free_regions_from_same_fn(sub={}, sup={})", sub, sup); + debug!("free_regions_from_same_fn(sub={:?}, sup={:?})", sub, sup); let (scope_id, fr1, fr2) = match (sub, sup) { (ReFree(fr1), ReFree(fr2)) => { if fr1.scope != fr2.scope { diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index bf0a9cfbea66d..10e4bdfffcb88 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -154,7 +154,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C // Regions that pre-dated the LUB computation stay as they are. if !is_var_in_set(new_vars, r0) { assert!(!r0.is_bound()); - debug!("generalize_region(r0={}): not new variable", r0); + debug!("generalize_region(r0={:?}): not new variable", r0); return r0; } @@ -164,8 +164,8 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C // *related* to regions that pre-date the LUB computation // stay as they are. if !tainted.iter().all(|r| is_var_in_set(new_vars, *r)) { - debug!("generalize_region(r0={}): \ - non-new-variables found in {}", + debug!("generalize_region(r0={:?}): \ + non-new-variables found in {:?}", r0, tainted); assert!(!r0.is_bound()); return r0; @@ -178,8 +178,8 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C // with. for (a_br, a_r) in a_map.iter() { if tainted.iter().any(|x| x == a_r) { - debug!("generalize_region(r0={}): \ - replacing with {}, tainted={}", + debug!("generalize_region(r0={:?}): \ + replacing with {:?}, tainted={:?}", r0, *a_br, tainted); return ty::ReLateBound(debruijn, *a_br); } @@ -187,7 +187,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C infcx.tcx.sess.span_bug( span, - format!("region {} is not associated with \ + format!("region {:?} is not associated with \ any bound region from A!", r0)[]) } @@ -322,7 +322,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C } infcx.tcx.sess.span_bug( span, - format!("could not find original bound region for {}", r)[]); + format!("could not find original bound region for {:?}", r)[]); } fn fresh_bound_variable(infcx: &InferCtxt, debruijn: ty::DebruijnIndex) -> ty::Region { @@ -339,7 +339,7 @@ fn var_ids<'tcx, T: Combine<'tcx>>(combiner: &T, r => { combiner.infcx().tcx.sess.span_bug( combiner.trace().origin.span(), - format!("found non-region-vid: {}", r)[]); + format!("found non-region-vid: {:?}", r)[]); } }).collect() } diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index c2db81d311483..9949286720bbf 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -989,7 +989,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { err: Option<&ty::type_err<'tcx>>) where M: FnOnce(Option, String) -> String, { - debug!("hi! expected_ty = {}, actual_ty = {}", expected_ty, actual_ty); + debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty); let resolved_expected = expected_ty.map(|e_ty| self.resolve_type_vars_if_possible(&e_ty)); @@ -1219,7 +1219,7 @@ impl<'tcx> Repr<'tcx> for SubregionOrigin<'tcx> { } Reborrow(a) => format!("Reborrow({})", a.repr(tcx)), ReborrowUpvar(a, b) => { - format!("ReborrowUpvar({},{})", a.repr(tcx), b) + format!("ReborrowUpvar({},{:?})", a.repr(tcx), b) } ReferenceOutlivesReferent(_, a) => { format!("ReferenceOutlivesReferent({})", a.repr(tcx)) @@ -1277,7 +1277,7 @@ impl<'tcx> Repr<'tcx> for RegionVariableOrigin<'tcx> { format!("EarlyBoundRegion({},{})", a.repr(tcx), b.repr(tcx)) } LateBoundRegion(a, b, c) => { - format!("LateBoundRegion({},{},{})", a.repr(tcx), b.repr(tcx), c) + format!("LateBoundRegion({},{},{:?})", a.repr(tcx), b.repr(tcx), c) } BoundRegionInCoherence(a) => { format!("bound_regionInCoherence({})", a.repr(tcx)) diff --git a/src/librustc/middle/infer/region_inference/graphviz.rs b/src/librustc/middle/infer/region_inference/graphviz.rs index 98c69962bc288..16169610b52e9 100644 --- a/src/librustc/middle/infer/region_inference/graphviz.rs +++ b/src/librustc/middle/infer/region_inference/graphviz.rs @@ -67,7 +67,7 @@ pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a, } let requested_output = os::getenv("RUST_REGION_GRAPH"); - debug!("requested_output: {} requested_node: {}", + debug!("requested_output: {:?} requested_node: {:?}", requested_output, requested_node); let output_path = { @@ -166,7 +166,7 @@ impl<'a, 'tcx> dot::Labeller<'a, Node, Edge> for ConstraintGraph<'a, 'tcx> { fn node_label(&self, n: &Node) -> dot::LabelText { match *n { Node::RegionVid(n_vid) => - dot::LabelText::label(format!("{}", n_vid)), + dot::LabelText::label(format!("{:?}", n_vid)), Node::Region(n_rgn) => dot::LabelText::label(format!("{}", n_rgn.repr(self.tcx))), } @@ -204,12 +204,12 @@ impl<'a, 'tcx> dot::GraphWalk<'a, Node, Edge> for ConstraintGraph<'a, 'tcx> { } fn source(&self, edge: &Edge) -> Node { let (n1, _) = constraint_to_nodes(edge); - debug!("edge {} has source {}", edge, n1); + debug!("edge {:?} has source {:?}", edge, n1); n1 } fn target(&self, edge: &Edge) -> Node { let (_, n2) = constraint_to_nodes(edge); - debug!("edge {} has target {}", edge, n2); + debug!("edge {:?} has target {:?}", edge, n2); n2 } } diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index d30a6ff1cd9d5..e936f79d934d5 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -273,7 +273,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } pub fn rollback_to(&self, snapshot: RegionSnapshot) { - debug!("RegionVarBindings: rollback_to({})", snapshot); + debug!("RegionVarBindings: rollback_to({:?})", snapshot); let mut undo_log = self.undo_log.borrow_mut(); assert!(undo_log.len() > snapshot.length); assert!((*undo_log)[snapshot.length] == OpenSnapshot); @@ -325,7 +325,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if self.in_snapshot() { self.undo_log.borrow_mut().push(AddVar(vid)); } - debug!("created new region variable {} with origin {}", + debug!("created new region variable {:?} with origin {}", vid, origin.repr(self.tcx)); return vid; } @@ -427,7 +427,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { let mut givens = self.givens.borrow_mut(); if givens.insert((sub, sup)) { - debug!("add_given({} <= {})", + debug!("add_given({} <= {:?})", sub.repr(self.tcx), sup); @@ -565,7 +565,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } Some(ref values) => { let r = lookup(values, rid); - debug!("resolve_var({}) = {}", rid, r.repr(self.tcx)); + debug!("resolve_var({:?}) = {}", rid, r.repr(self.tcx)); r } } @@ -602,7 +602,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } relate(self, a, ReInfer(ReVar(c))); relate(self, b, ReInfer(ReVar(c))); - debug!("combine_vars() c={}", c); + debug!("combine_vars() c={:?}", c); ReInfer(ReVar(c)) } @@ -623,7 +623,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { /// made---`r0` itself will be the first entry. This is used when checking whether skolemized /// regions are being improperly related to other regions. pub fn tainted(&self, mark: &RegionSnapshot, r0: Region) -> Vec { - debug!("tainted(mark={}, r0={})", mark, r0.repr(self.tcx)); + debug!("tainted(mark={:?}, r0={})", mark, r0.repr(self.tcx)); let _indenter = indenter(); // `result_set` acts as a worklist: we explore all outgoing @@ -634,7 +634,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { while result_index < result_set.len() { // nb: can't use uint::range() here because result_set grows let r = result_set[result_index]; - debug!("result_index={}, r={}", result_index, r); + debug!("result_index={}, r={:?}", result_index, r); for undo_entry in self.undo_log.borrow().slice_from(mark.length).iter() @@ -751,7 +751,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[v_id.index as uint].span(), format!("lub_concrete_regions invoked with \ - non-concrete regions: {}, {}", + non-concrete regions: {:?}, {:?}", a, b)[]); } @@ -827,7 +827,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a: Region, b: Region) -> cres<'tcx, Region> { - debug!("glb_concrete_regions({}, {})", a, b); + debug!("glb_concrete_regions({:?}, {:?})", a, b); match (a, b) { (ReLateBound(..), _) | (_, ReLateBound(..)) | @@ -854,7 +854,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[v_id.index as uint].span(), format!("glb_concrete_regions invoked with \ - non-concrete regions: {}, {}", + non-concrete regions: {:?}, {:?}", a, b)[]); } @@ -932,7 +932,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { // scopes or two free regions. So, if one of // these scopes is a subscope of the other, return // it. Otherwise fail. - debug!("intersect_scopes(scope_a={}, scope_b={}, region_a={}, region_b={})", + debug!("intersect_scopes(scope_a={:?}, scope_b={:?}, region_a={:?}, region_b={:?})", scope_a, scope_b, region_a, region_b); match self.tcx.region_maps.nearest_common_ancestor(scope_a, scope_b) { Some(r_id) if scope_a == r_id => Ok(ReScope(scope_b)), @@ -971,7 +971,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { // Dorky hack to cause `dump_constraints` to only get called // if debug mode is enabled: - debug!("----() End constraint listing {}---", self.dump_constraints()); + debug!("----() End constraint listing {:?}---", self.dump_constraints()); graphviz::maybe_print_constraints_for(self, subject); self.expansion(var_data.as_mut_slice()); @@ -1039,7 +1039,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { b_data: &mut VarData) -> bool { - debug!("expand_node({}, {} == {})", + debug!("expand_node({}, {:?} == {})", a_region.repr(self.tcx), b_vid, b_data.value.repr(self.tcx)); @@ -1058,7 +1058,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { b_data.classification = Expanding; match b_data.value { NoValue => { - debug!("Setting initial value of {} to {}", + debug!("Setting initial value of {:?} to {}", b_vid, a_region.repr(self.tcx)); b_data.value = Value(a_region); @@ -1071,7 +1071,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { return false; } - debug!("Expanding value of {} from {} to {}", + debug!("Expanding value of {:?} from {} to {}", b_vid, cur_region.repr(self.tcx), lub.repr(self.tcx)); @@ -1122,7 +1122,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a_data: &mut VarData, b_region: Region) -> bool { - debug!("contract_node({} == {}/{}, {})", + debug!("contract_node({:?} == {}/{:?}, {})", a_vid, a_data.value.repr(self.tcx), a_data.classification, b_region.repr(self.tcx)); @@ -1156,7 +1156,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { b_region: Region) -> bool { if !this.is_subregion_of(a_region, b_region) { - debug!("Setting {} to ErrorValue: {} not subregion of {}", + debug!("Setting {:?} to ErrorValue: {} not subregion of {}", a_vid, a_region.repr(this.tcx), b_region.repr(this.tcx)); @@ -1176,7 +1176,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if glb == a_region { false } else { - debug!("Contracting value of {} from {} to {}", + debug!("Contracting value of {:?} from {} to {}", a_vid, a_region.repr(this.tcx), glb.repr(this.tcx)); @@ -1185,7 +1185,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } } Err(_) => { - debug!("Setting {} to ErrorValue: no glb of {}, {}", + debug!("Setting {:?} to ErrorValue: no glb of {}, {}", a_vid, a_region.repr(this.tcx), b_region.repr(this.tcx)); @@ -1412,7 +1412,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[node_idx.index as uint].span(), format!("collect_error_for_expanding_node() could not find error \ - for var {}, lower_bounds={}, upper_bounds={}", + for var {:?}, lower_bounds={}, upper_bounds={}", node_idx, lower_bounds.repr(self.tcx), upper_bounds.repr(self.tcx))[]); @@ -1457,7 +1457,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { self.tcx.sess.span_bug( (*self.var_origins.borrow())[node_idx.index as uint].span(), format!("collect_error_for_contracting_node() could not find error \ - for var {}, upper_bounds={}", + for var {:?}, upper_bounds={}", node_idx, upper_bounds.repr(self.tcx))[]); } @@ -1498,8 +1498,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { state.dup_found = true; } - debug!("collect_concrete_regions(orig_node_idx={}, node_idx={}, \ - classification={})", + debug!("collect_concrete_regions(orig_node_idx={:?}, node_idx={:?}, \ + classification={:?})", orig_node_idx, node_idx, classification); // figure out the direction from which this node takes its @@ -1520,7 +1520,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { graph: &RegionGraph, source_vid: RegionVid, dir: Direction) { - debug!("process_edges(source_vid={}, dir={})", source_vid, dir); + debug!("process_edges(source_vid={:?}, dir={:?})", source_vid, dir); let source_node_index = NodeIndex(source_vid.index as uint); graph.each_adjacent_edge(source_node_index, dir, |_, edge| { diff --git a/src/librustc/middle/infer/type_variable.rs b/src/librustc/middle/infer/type_variable.rs index 2aacc863f54c9..3f3e4c50e7047 100644 --- a/src/librustc/middle/infer/type_variable.rs +++ b/src/librustc/middle/infer/type_variable.rs @@ -184,7 +184,7 @@ impl<'tcx> TypeVariableTable<'tcx> { let escaping_type = self.probe(vid).unwrap(); escaping_types.push(escaping_type); } - debug!("SpecifyVar({}) new_elem_threshold={}", vid, new_elem_threshold); + debug!("SpecifyVar({:?}) new_elem_threshold={}", vid, new_elem_threshold); } _ => { } diff --git a/src/librustc/middle/infer/unify.rs b/src/librustc/middle/infer/unify.rs index 73da96445934c..2d70e2cdc4dc9 100644 --- a/src/librustc/middle/infer/unify.rs +++ b/src/librustc/middle/infer/unify.rs @@ -129,7 +129,7 @@ impl<'tcx, V:PartialEq+Clone+Repr<'tcx>, K:UnifyKey<'tcx, V>> UnificationTable K { let index = self.values.push(Root(value, 0)); let k = UnifyKey::from_index(index); - debug!("{}: created new key: {}", + debug!("{}: created new key: {:?}", UnifyKey::tag(None::), k); k diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index a83416667abdc..41f293cfca52c 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -209,7 +209,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { } Some((space, index, ¶m_ty)) => { - debug!("with_each_combination: space={}, index={}, param_ty={}", + debug!("with_each_combination: space={:?}, index={}, param_ty={}", space, index, param_ty.repr(self.tcx)); if !ty::type_is_sized(param_env, span, param_ty) { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 77875139be3a3..c1ae8a2f6e592 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -289,7 +289,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { self.lnks.push(lnk); self.num_live_nodes += 1; - debug!("{} is of kind {}", ln.to_string(), + debug!("{:?} is of kind {}", ln, live_node_kind_to_string(lnk, self.tcx)); ln @@ -299,7 +299,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { let ln = self.add_live_node(lnk); self.live_node_map.insert(node_id, ln); - debug!("{} is node {}", ln.to_string(), node_id); + debug!("{:?} is node {}", ln, node_id); } fn add_variable(&mut self, vk: VarKind) -> Variable { @@ -314,7 +314,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { ImplicitRet | CleanExit => {} } - debug!("{} is {}", v.to_string(), vk); + debug!("{:?} is {:?}", v, vk); v } @@ -377,7 +377,7 @@ fn visit_fn(ir: &mut IrMaps, // swap in a new set of IR maps for this function body: let mut fn_maps = IrMaps::new(ir.tcx); - debug!("creating fn_maps: {}", &fn_maps as *const IrMaps); + debug!("creating fn_maps: {:?}", &fn_maps as *const IrMaps); for arg in decl.inputs.iter() { pat_util::pat_bindings(&ir.tcx.def_map, @@ -430,7 +430,7 @@ fn visit_local(ir: &mut IrMaps, local: &ast::Local) { fn visit_arm(ir: &mut IrMaps, arm: &ast::Arm) { for pat in arm.pats.iter() { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { - debug!("adding local variable {} from match with bm {}", + debug!("adding local variable {} from match with bm {:?}", p_id, bm); let name = path1.node; ir.add_live_node_for_node(p_id, VarDefNode(sp)); @@ -448,7 +448,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { // live nodes required for uses or definitions of variables: ast::ExprPath(_) => { let def = ir.tcx.def_map.borrow()[expr.id].clone(); - debug!("expr {}: path that leads to {}", expr.id, def); + debug!("expr {}: path that leads to {:?}", expr.id, def); if let DefLocal(..) = def { ir.add_live_node_for_node(expr.id, ExprNode(expr.span)); } @@ -491,7 +491,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { } ast::ExprForLoop(ref pat, _, _, _) => { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { - debug!("adding local variable {} from for loop with bm {}", + debug!("adding local variable {} from for loop with bm {:?}", p_id, bm); let name = path1.node; ir.add_live_node_for_node(p_id, VarDefNode(sp)); @@ -702,7 +702,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { for var_idx in range(0u, self.ir.num_vars) { let idx = node_base_idx + var_idx; if test(idx).is_valid() { - try!(write!(wr, " {}", Variable(var_idx).to_string())); + try!(write!(wr, " {:?}", Variable(var_idx))); } } Ok(()) @@ -740,11 +740,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { let mut wr = Vec::new(); { let wr = &mut wr as &mut io::Writer; - write!(wr, "[ln({}) of kind {} reads", ln.get(), self.ir.lnk(ln)); + write!(wr, "[ln({:?}) of kind {:?} reads", ln.get(), self.ir.lnk(ln)); self.write_vars(wr, ln, |idx| self.users[idx].reader); write!(wr, " writes"); self.write_vars(wr, ln, |idx| self.users[idx].writer); - write!(wr, " precedes {}]", self.successors[ln.get()].to_string()); + write!(wr, " precedes {:?}]", self.successors[ln.get()]); } String::from_utf8(wr).unwrap() } @@ -792,8 +792,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } }); - debug!("merge_from_succ(ln={}, succ={}, first_merge={}, changed={})", - ln.to_string(), self.ln_str(succ_ln), first_merge, changed); + debug!("merge_from_succ(ln={:?}, succ={}, first_merge={}, changed={})", + ln, self.ln_str(succ_ln), first_merge, changed); return changed; fn copy_if_invalid(src: LiveNode, dst: &mut LiveNode) -> bool { @@ -814,14 +814,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { self.users[idx].reader = invalid_node(); self.users[idx].writer = invalid_node(); - debug!("{} defines {} (idx={}): {}", writer.to_string(), var.to_string(), + debug!("{:?} defines {:?} (idx={}): {}", writer, var, idx, self.ln_str(writer)); } // Either read, write, or both depending on the acc bitset fn acc(&mut self, ln: LiveNode, var: Variable, acc: uint) { - debug!("{} accesses[{:x}] {}: {}", - ln.to_string(), acc, var.to_string(), self.ln_str(ln)); + debug!("{:?} accesses[{:x}] {:?}: {}", + ln, acc, var, self.ln_str(ln)); let idx = self.idx(ln, var); let user = &mut self.users[idx]; @@ -857,14 +857,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { |this| this.propagate_through_fn_block(decl, body)); // hack to skip the loop unless debug! is enabled: - debug!("^^ liveness computation results for body {} (entry={})", + debug!("^^ liveness computation results for body {} (entry={:?})", { for ln_idx in range(0u, self.ir.num_live_nodes) { - debug!("{}", self.ln_str(LiveNode(ln_idx))); + debug!("{:?}", self.ln_str(LiveNode(ln_idx))); } body.id }, - entry_ln.to_string()); + entry_ln); entry_ln } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2b8c9b532e593..91f1ffab7929e 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -547,7 +547,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { expr_ty: Ty<'tcx>, def: def::Def) -> McResult> { - debug!("cat_def: id={} expr={} def={}", + debug!("cat_def: id={} expr={} def={:?}", id, expr_ty.repr(self.tcx()), def); match def { @@ -860,7 +860,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { }; let method_ty = self.typer.node_method_ty(method_call); - debug!("cat_deref: method_call={} method_ty={}", + debug!("cat_deref: method_call={:?} method_ty={:?}", method_call, method_ty.map(|ty| ty.repr(self.tcx()))); let base_cmt = match method_ty { @@ -1455,7 +1455,7 @@ impl<'tcx> cmt_<'tcx> { impl<'tcx> Repr<'tcx> for cmt_<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { - format!("{{{} id:{} m:{} ty:{}}}", + format!("{{{} id:{} m:{:?} ty:{}}}", self.cat.repr(tcx), self.id, self.mutbl, @@ -1470,7 +1470,7 @@ impl<'tcx> Repr<'tcx> for categorization<'tcx> { cat_rvalue(..) | cat_local(..) | cat_upvar(..) => { - format!("{}", *self) + format!("{:?}", *self) } cat_deref(ref cmt, derefs, ptr) => { format!("{}-{}{}->", cmt.cat.repr(tcx), ptr_sigil(ptr), derefs) diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 50e328ef0e3c3..f978152563242 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -435,28 +435,28 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { fn def_privacy(&self, did: ast::DefId) -> PrivacyResult { if !is_local(did) { if self.external_exports.contains(&did) { - debug!("privacy - {} was externally exported", did); + debug!("privacy - {:?} was externally exported", did); return Allowable; } - debug!("privacy - is {} a public method", did); + debug!("privacy - is {:?} a public method", did); return match self.tcx.impl_or_trait_items.borrow().get(&did) { Some(&ty::MethodTraitItem(ref meth)) => { - debug!("privacy - well at least it's a method: {}", + debug!("privacy - well at least it's a method: {:?}", *meth); match meth.container { ty::TraitContainer(id) => { - debug!("privacy - recursing on trait {}", id); + debug!("privacy - recursing on trait {:?}", id); self.def_privacy(id) } ty::ImplContainer(id) => { match ty::impl_trait_ref(self.tcx, id) { Some(t) => { - debug!("privacy - impl of trait {}", id); + debug!("privacy - impl of trait {:?}", id); self.def_privacy(t.def_id) } None => { - debug!("privacy - found a method {}", + debug!("privacy - found a method {:?}", meth.vis); if meth.vis == ast::Public { Allowable @@ -471,17 +471,17 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { Some(&ty::TypeTraitItem(ref typedef)) => { match typedef.container { ty::TraitContainer(id) => { - debug!("privacy - recursing on trait {}", id); + debug!("privacy - recursing on trait {:?}", id); self.def_privacy(id) } ty::ImplContainer(id) => { match ty::impl_trait_ref(self.tcx, id) { Some(t) => { - debug!("privacy - impl of trait {}", id); + debug!("privacy - impl of trait {:?}", id); self.def_privacy(t.def_id) } None => { - debug!("privacy - found a typedef {}", + debug!("privacy - found a typedef {:?}", typedef.vis); if typedef.vis == ast::Public { Allowable @@ -696,7 +696,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { let fields = ty::lookup_struct_fields(self.tcx, id); let field = match name { NamedField(ident) => { - debug!("privacy - check named field {} in struct {}", ident.name, id); + debug!("privacy - check named field {} in struct {:?}", ident.name, id); fields.iter().find(|f| f.name == ident.name).unwrap() } UnnamedField(idx) => &fields[idx] diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 68e257bc0c5ec..5d33a7efd3bee 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -146,24 +146,24 @@ impl RegionMaps { None => {} } - debug!("relate_free_regions(sub={}, sup={})", sub, sup); + debug!("relate_free_regions(sub={:?}, sup={:?})", sub, sup); self.free_region_map.borrow_mut().insert(sub, vec!(sup)); } pub fn record_encl_scope(&self, sub: CodeExtent, sup: CodeExtent) { - debug!("record_encl_scope(sub={}, sup={})", sub, sup); + debug!("record_encl_scope(sub={:?}, sup={:?})", sub, sup); assert!(sub != sup); self.scope_map.borrow_mut().insert(sub, sup); } pub fn record_var_scope(&self, var: ast::NodeId, lifetime: CodeExtent) { - debug!("record_var_scope(sub={}, sup={})", var, lifetime); + debug!("record_var_scope(sub={:?}, sup={:?})", var, lifetime); assert!(var != lifetime.node_id()); self.var_map.borrow_mut().insert(var, lifetime); } pub fn record_rvalue_scope(&self, var: ast::NodeId, lifetime: CodeExtent) { - debug!("record_rvalue_scope(sub={}, sup={})", var, lifetime); + debug!("record_rvalue_scope(sub={:?}, sup={:?})", var, lifetime); assert!(var != lifetime.node_id()); self.rvalue_scopes.borrow_mut().insert(var, lifetime); } @@ -172,7 +172,7 @@ impl RegionMaps { /// e.g. by an expression like `a().f` -- they will be freed within the innermost terminating /// scope. pub fn mark_as_terminating_scope(&self, scope_id: CodeExtent) { - debug!("record_terminating_scope(scope_id={})", scope_id); + debug!("record_terminating_scope(scope_id={:?})", scope_id); self.terminating_scopes.borrow_mut().insert(scope_id); } @@ -186,7 +186,7 @@ impl RegionMaps { //! Returns the narrowest scope that encloses `id`, if any. match self.scope_map.borrow().get(&id) { Some(&r) => r, - None => { panic!("no enclosing scope for id {}", id); } + None => { panic!("no enclosing scope for id {:?}", id); } } } @@ -194,7 +194,7 @@ impl RegionMaps { pub fn var_scope(&self, var_id: ast::NodeId) -> CodeExtent { match self.var_map.borrow().get(&var_id) { Some(&r) => r, - None => { panic!("no enclosing scope for id {}", var_id); } + None => { panic!("no enclosing scope for id {:?}", var_id); } } } @@ -204,7 +204,7 @@ impl RegionMaps { // check for a designated rvalue scope match self.rvalue_scopes.borrow().get(&expr_id) { Some(&s) => { - debug!("temporary_scope({}) = {} [custom]", expr_id, s); + debug!("temporary_scope({:?}) = {:?} [custom]", expr_id, s); return Some(s); } None => { } @@ -225,12 +225,12 @@ impl RegionMaps { id = p; } None => { - debug!("temporary_scope({}) = None", expr_id); + debug!("temporary_scope({:?}) = None", expr_id); return None; } } } - debug!("temporary_scope({}) = {} [enclosing]", expr_id, id); + debug!("temporary_scope({:?}) = {:?} [enclosing]", expr_id, id); return Some(id); } @@ -238,7 +238,7 @@ impl RegionMaps { //! Returns the lifetime of the variable `id`. let scope = ty::ReScope(self.var_scope(id)); - debug!("var_region({}) = {}", id, scope); + debug!("var_region({:?}) = {:?}", id, scope); scope } @@ -258,7 +258,7 @@ impl RegionMaps { while superscope != s { match self.scope_map.borrow().get(&s) { None => { - debug!("is_subscope_of({}, {}, s={})=false", + debug!("is_subscope_of({:?}, {:?}, s={:?})=false", subscope, superscope, s); return false; @@ -267,7 +267,7 @@ impl RegionMaps { } } - debug!("is_subscope_of({}, {})=true", + debug!("is_subscope_of({:?}, {:?})=true", subscope, superscope); return true; @@ -287,7 +287,7 @@ impl RegionMaps { sub_region: ty::Region, super_region: ty::Region) -> bool { - debug!("is_subregion_of(sub_region={}, super_region={})", + debug!("is_subregion_of(sub_region={:?}, super_region={:?})", sub_region, super_region); sub_region == super_region || { @@ -365,7 +365,7 @@ impl RegionMaps { fn ancestors_of(this: &RegionMaps, scope: CodeExtent) -> Vec { - // debug!("ancestors_of(scope={})", scope); + // debug!("ancestors_of(scope={:?})", scope); let mut result = vec!(scope); let mut scope = scope; loop { @@ -376,7 +376,7 @@ impl RegionMaps { scope = superscope; } } - // debug!("ancestors_of_loop(scope={})", scope); + // debug!("ancestors_of_loop(scope={:?})", scope); } } } @@ -414,7 +414,7 @@ fn record_var_lifetime(visitor: &mut RegionResolutionVisitor, } fn resolve_block(visitor: &mut RegionResolutionVisitor, blk: &ast::Block) { - debug!("resolve_block(blk.id={})", blk.id); + debug!("resolve_block(blk.id={:?})", blk.id); // Record the parent of this block. record_superlifetime(visitor, blk.id, blk.span); @@ -466,7 +466,7 @@ fn resolve_pat(visitor: &mut RegionResolutionVisitor, pat: &ast::Pat) { fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &ast::Stmt) { let stmt_id = stmt_id(stmt); - debug!("resolve_stmt(stmt.id={})", stmt_id); + debug!("resolve_stmt(stmt.id={:?})", stmt_id); let stmt_scope = CodeExtent::from_node_id(stmt_id); visitor.region_maps.mark_as_terminating_scope(stmt_scope); @@ -479,7 +479,7 @@ fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &ast::Stmt) { } fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) { - debug!("resolve_expr(expr.id={})", expr.id); + debug!("resolve_expr(expr.id={:?})", expr.id); record_superlifetime(visitor, expr.id, expr.span); @@ -566,7 +566,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) { } fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) { - debug!("resolve_local(local.id={},local.init={})", + debug!("resolve_local(local.id={:?},local.init={:?})", local.id,local.init.is_some()); let blk_id = match visitor.cx.var_parent { @@ -815,10 +815,10 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor, body: &ast::Block, sp: Span, id: ast::NodeId) { - debug!("region::resolve_fn(id={}, \ - span={}, \ - body.id={}, \ - cx.parent={})", + debug!("region::resolve_fn(id={:?}, \ + span={:?}, \ + body.id={:?}, \ + cx.parent={:?})", id, visitor.sess.codemap().span_to_string(sp), body.id, diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 68cb8ca39b492..09de2b361c52e 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -223,7 +223,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { fn visit_poly_trait_ref(&mut self, trait_ref: &ast::PolyTraitRef, _modifier: &ast::TraitBoundModifier) { - debug!("visit_poly_trait_ref trait_ref={}", trait_ref); + debug!("visit_poly_trait_ref trait_ref={:?}", trait_ref); self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| { this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes); @@ -250,9 +250,9 @@ impl<'a> LifetimeContext<'a> { scope: &wrap_scope, def_map: self.def_map, }; - debug!("entering scope {}", this.scope); + debug!("entering scope {:?}", this.scope); f(self.scope, &mut this); - debug!("exiting scope {}", this.scope); + debug!("exiting scope {:?}", this.scope); } /// Visits self by adding a scope and handling recursive walk over the contents with `walk`. @@ -281,7 +281,7 @@ impl<'a> LifetimeContext<'a> { { let referenced_idents = early_bound_lifetime_names(generics); - debug!("visit_early_late: referenced_idents={}", + debug!("visit_early_late: referenced_idents={:?}", referenced_idents); let (early, late): (Vec<_>, _) = generics.lifetimes.iter().cloned().partition( @@ -488,7 +488,7 @@ impl<'a> LifetimeContext<'a> { probably a bug in syntax::fold"); } - debug!("lifetime_ref={} id={} resolved to {}", + debug!("lifetime_ref={:?} id={:?} resolved to {:?}", lifetime_to_string(lifetime_ref), lifetime_ref.id, def); @@ -605,9 +605,9 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { impl<'a> fmt::Show for ScopeChain<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - EarlyScope(space, defs, _) => write!(fmt, "EarlyScope({}, {})", space, defs), - LateScope(defs, _) => write!(fmt, "LateScope({})", defs), - BlockScope(id, _) => write!(fmt, "BlockScope({})", id), + EarlyScope(space, defs, _) => write!(fmt, "EarlyScope({:?}, {:?})", space, defs), + LateScope(defs, _) => write!(fmt, "LateScope({:?})", defs), + BlockScope(id, _) => write!(fmt, "BlockScope({:?})", id), RootScope => write!(fmt, "RootScope"), } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 362d5fedaa376..359ad8d394129 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -161,7 +161,7 @@ pub fn lookup(tcx: &ty::ctxt, id: DefId) -> Option { // is this definition the implementation of a trait method? match ty::trait_item_of_item(tcx, id) { Some(ty::MethodTraitItemId(trait_method_id)) if trait_method_id != id => { - debug!("lookup: trait_method_id={}", trait_method_id); + debug!("lookup: trait_method_id={:?}", trait_method_id); return lookup(tcx, trait_method_id) } _ => {} @@ -182,7 +182,7 @@ pub fn lookup(tcx: &ty::ctxt, id: DefId) -> Option { // stability of the trait to determine the stability of any // unmarked impls for it. See FIXME above for more details. - debug!("lookup: trait_id={}", trait_id); + debug!("lookup: trait_id={:?}", trait_id); lookup(tcx, trait_id) } else { None diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index cd29ce28ac174..f496200da1371 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -242,7 +242,7 @@ impl fmt::Show for VecPerParamSpace { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "VecPerParamSpace {{")); for space in ParamSpace::all().iter() { - try!(write!(fmt, "{}: {}, ", *space, self.get_slice(*space))); + try!(write!(fmt, "{:?}: {:?}, ", *space, self.get_slice(*space))); } try!(write!(fmt, "}}")); Ok(()) @@ -601,7 +601,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> { span, format!("Type parameter out of range \ when substituting in region {} (root type={}) \ - (space={}, index={})", + (space={:?}, index={})", region_name.as_str(), self.root_ty.repr(self.tcx()), space, i)[]); @@ -654,7 +654,7 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> { let span = self.span.unwrap_or(DUMMY_SP); self.tcx().sess.span_bug( span, - format!("Type parameter `{}` ({}/{}/{}) out of range \ + format!("Type parameter `{}` ({}/{:?}/{}) out of range \ when substituting (root type={}) substs={}", p.repr(self.tcx()), source_ty.repr(self.tcx()), @@ -711,7 +711,7 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> { /// first case we do not increase the Debruijn index and in the second case we do. The reason /// is that only in the second case have we passed through a fn binder. fn shift_regions_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> { - debug!("shift_regions(ty={}, region_binders_passed={}, type_has_escaping_regions={})", + debug!("shift_regions(ty={:?}, region_binders_passed={:?}, type_has_escaping_regions={:?})", ty.repr(self.tcx()), self.region_binders_passed, ty::type_has_escaping_regions(ty)); if self.region_binders_passed == 0 || !ty::type_has_escaping_regions(ty) { @@ -719,7 +719,7 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> { } let result = ty_fold::shift_regions(self.tcx(), self.region_binders_passed, &ty); - debug!("shift_regions: shifted result = {}", result.repr(self.tcx())); + debug!("shift_regions: shifted result = {:?}", result.repr(self.tcx())); result } diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index ce926fd8d10de..4343daf2f0b95 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -297,7 +297,7 @@ pub fn evaluate_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, span: Span) -> SelectionResult<'tcx, ()> { - debug!("type_known_to_meet_builtin_bound(ty={}, bound={})", + debug!("type_known_to_meet_builtin_bound(ty={}, bound={:?})", ty.repr(infcx.tcx), bound); @@ -347,7 +347,7 @@ pub fn evaluate_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, } }; - debug!("type_known_to_meet_builtin_bound: ty={} bound={} result={}", + debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} result={:?}", ty.repr(infcx.tcx), bound, result); diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index 8880cb7ce733f..84b41f28ecee3 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -295,7 +295,7 @@ impl<'tcx> Repr<'tcx> for ObjectSafetyViolation<'tcx> { ObjectSafetyViolation::SizedSelf => format!("SizedSelf"), ObjectSafetyViolation::Method(ref m, code) => - format!("Method({},{})", m.repr(tcx), code), + format!("Method({},{:?})", m.repr(tcx), code), } } } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 2393b7d733d00..36cc62172fde3 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -368,7 +368,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let result = self.evaluate_stack(&stack); - debug!("result: {}", result); + debug!("result: {:?}", result); result } @@ -944,14 +944,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { _ => { return Ok(()); } }; - debug!("assemble_unboxed_candidates: self_ty={} kind={} obligation={}", + debug!("assemble_unboxed_candidates: self_ty={} kind={:?} obligation={}", self_ty.repr(self.tcx()), kind, obligation.repr(self.tcx())); let closure_kind = self.closure_typer.unboxed_closure_kind(closure_def_id); - debug!("closure_kind = {}", closure_kind); + debug!("closure_kind = {:?}", closure_kind); if closure_kind == kind { candidates.vec.push(UnboxedClosureCandidate(closure_def_id, substs.clone())); @@ -1102,7 +1102,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Err(error) => EvaluatedToErr(error), } }); - debug!("winnow_candidate depth={} result={}", + debug!("winnow_candidate depth={} result={:?}", stack.obligation.recursion_depth, result); result } @@ -1716,7 +1716,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let substs = self.rematch_impl(impl_def_id, obligation, snapshot, &skol_map, skol_obligation_trait_ref.trait_ref); - debug!("confirm_impl_candidate substs={}", substs); + debug!("confirm_impl_candidate substs={:?}", substs); Ok(self.vtable_impl(impl_def_id, substs, obligation.cause.clone(), obligation.recursion_depth + 1, skol_map, snapshot)) }) @@ -2225,7 +2225,7 @@ impl<'tcx> Repr<'tcx> for SelectionCandidate<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { match *self { ErrorCandidate => format!("ErrorCandidate"), - BuiltinCandidate(b) => format!("BuiltinCandidate({})", b), + BuiltinCandidate(b) => format!("BuiltinCandidate({:?})", b), ParamCandidate(ref a) => format!("ParamCandidate({})", a.repr(tcx)), ImplCandidate(a) => format!("ImplCandidate({})", a.repr(tcx)), ProjectionCandidate => format!("ProjectionCandidate"), @@ -2234,7 +2234,7 @@ impl<'tcx> Repr<'tcx> for SelectionCandidate<'tcx> { format!("ObjectCandidate") } UnboxedClosureCandidate(c, ref s) => { - format!("UnboxedClosureCandidate({},{})", c, s.repr(tcx)) + format!("UnboxedClosureCandidate({:?},{})", c, s.repr(tcx)) } } } diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index 229d34fe4237c..272447027afd8 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -238,7 +238,7 @@ pub fn fresh_substs_for_impl<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, impl<'tcx, N> fmt::Show for VtableImplData<'tcx, N> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "VtableImpl({})", self.impl_def_id) + write!(f, "VtableImpl({:?})", self.impl_def_id) } } @@ -451,8 +451,8 @@ impl<'tcx> Repr<'tcx> for super::FulfillmentErrorCode<'tcx> { impl<'tcx> fmt::Show for super::FulfillmentErrorCode<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - super::CodeSelectionError(ref e) => write!(f, "{}", e), - super::CodeProjectionError(ref e) => write!(f, "{}", e), + super::CodeSelectionError(ref e) => write!(f, "{:?}", e), + super::CodeProjectionError(ref e) => write!(f, "{:?}", e), super::CodeAmbiguity => write!(f, "Ambiguity") } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c359233eca173..9fcf0b4f2d3df 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -1710,8 +1710,8 @@ impl fmt::Show for InferTy { TyVar(ref v) => v.fmt(f), IntVar(ref v) => v.fmt(f), FloatVar(ref v) => v.fmt(f), - FreshTy(v) => write!(f, "FreshTy({})", v), - FreshIntTy(v) => write!(f, "FreshIntTy({})", v), + FreshTy(v) => write!(f, "FreshTy({:?})", v), + FreshIntTy(v) => write!(f, "FreshIntTy({:?})", v), } } } @@ -2471,7 +2471,7 @@ fn intern_ty<'tcx>(type_arena: &'tcx TypedArena>, region_depth: flags.depth, }); - debug!("Interned type: {} Pointer: {}", + debug!("Interned type: {:?} Pointer: {:?}", ty, ty as *const _); interner.insert(InternedTy { ty: ty }, ty); @@ -3533,7 +3533,7 @@ fn type_impls_bound<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, match cache.borrow().get(&ty) { None => {} Some(&result) => { - debug!("type_impls_bound({}, {}) = {} (cached)", + debug!("type_impls_bound({}, {:?}) = {:?} (cached)", ty.repr(param_env.tcx), bound, result); @@ -3546,7 +3546,7 @@ fn type_impls_bound<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span); - debug!("type_impls_bound({}, {}) = {}", + debug!("type_impls_bound({}, {:?}) = {:?}", ty.repr(param_env.tcx), bound, is_impld); @@ -3585,13 +3585,13 @@ pub fn is_ffi_safe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool { pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { - debug!("type_requires({}, {})?", + debug!("type_requires({:?}, {:?})?", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty)); let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty); - debug!("type_requires({}, {})? {}", + debug!("type_requires({:?}, {:?})? {:?}", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty), r); @@ -3600,7 +3600,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { - debug!("subtypes_require({}, {})?", + debug!("subtypes_require({:?}, {:?})?", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty)); @@ -3655,7 +3655,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { ty_unboxed_closure(..) => { // this check is run on type definitions, so we don't expect to see // inference by-products or unboxed closure types - cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[]) + cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}", ty)[]) } ty_tup(ref ts) => { @@ -3680,7 +3680,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { } }; - debug!("subtypes_require({}, {})? {}", + debug!("subtypes_require({:?}, {:?})? {:?}", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty), r); @@ -3748,7 +3748,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) ty_unboxed_closure(..) => { // this check is run on type definitions, so we don't expect to see // unboxed closure types - cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[]) + cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}", ty)[]) } _ => Representable, } @@ -3789,7 +3789,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec>, ty: Ty<'tcx>) -> Representability { - debug!("is_type_structurally_recursive: {}", + debug!("is_type_structurally_recursive: {:?}", ::util::ppaux::ty_to_string(cx, ty)); match ty.sty { @@ -3809,7 +3809,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) match iter.next() { Some(&seen_type) => { if same_struct_or_enum_def_id(seen_type, did) { - debug!("SelfRecursive: {} contains {}", + debug!("SelfRecursive: {:?} contains {:?}", ::util::ppaux::ty_to_string(cx, seen_type), ::util::ppaux::ty_to_string(cx, ty)); return SelfRecursive; @@ -3829,7 +3829,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) for &seen_type in iter { if same_type(ty, seen_type) { - debug!("ContainsRecursive: {} contains {}", + debug!("ContainsRecursive: {:?} contains {:?}", ::util::ppaux::ty_to_string(cx, seen_type), ::util::ppaux::ty_to_string(cx, ty)); return ContainsRecursive; @@ -3851,7 +3851,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) } } - debug!("is_type_representable: {}", + debug!("is_type_representable: {:?}", ::util::ppaux::ty_to_string(cx, ty)); // To avoid a stack overflow when checking an enum variant or struct that @@ -3859,7 +3859,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) // of seen types and check recursion for each of them (issues #3008, #3779). let mut seen: Vec = Vec::new(); let r = is_type_structurally_recursive(cx, sp, &mut seen, ty); - debug!("is_type_representable: {} is {}", + debug!("is_type_representable: {:?} is {:?}", ::util::ppaux::ty_to_string(cx, ty), r); r } @@ -4122,7 +4122,7 @@ pub fn fn_is_variadic(fty: Ty) -> bool { match fty.sty { ty_bare_fn(_, ref f) => f.sig.0.variadic, ref s => { - panic!("fn_is_variadic() called on non-fn type: {}", s) + panic!("fn_is_variadic() called on non-fn type: {:?}", s) } } } @@ -4131,7 +4131,7 @@ pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx PolyFnSig<'tcx> { match fty.sty { ty_bare_fn(_, ref f) => &f.sig, ref s => { - panic!("ty_fn_sig() called on non-fn type: {}", s) + panic!("ty_fn_sig() called on non-fn type: {:?}", s) } } } @@ -4157,7 +4157,7 @@ pub fn ty_closure_store(fty: Ty) -> TraitStore { UniqTraitStore } ref s => { - panic!("ty_closure_store() called on non-closure type: {}", s) + panic!("ty_closure_store() called on non-closure type: {:?}", s) } } } @@ -4166,7 +4166,7 @@ pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> FnOutput<'tcx> { match fty.sty { ty_bare_fn(_, ref f) => f.sig.0.output, ref s => { - panic!("ty_fn_ret() called on non-fn type: {}", s) + panic!("ty_fn_ret() called on non-fn type: {:?}", s) } } } @@ -4186,7 +4186,7 @@ pub fn ty_region(tcx: &ctxt, ref s => { tcx.sess.span_bug( span, - format!("ty_region() invoked on an inappropriate ty: {}", + format!("ty_region() invoked on an inappropriate ty: {:?}", s)[]); } } @@ -4246,7 +4246,7 @@ pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { e.span } Some(f) => { - cx.sess.bug(format!("Node id {} is not an expr: {}", + cx.sess.bug(format!("Node id {} is not an expr: {:?}", id, f)[]); } @@ -4266,14 +4266,14 @@ pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { } _ => { cx.sess.bug( - format!("Variable id {} maps to {}, not local", + format!("Variable id {} maps to {:?}, not local", id, pat)[]); } } } r => { - cx.sess.bug(format!("Variable id {} maps to {}, not local", + cx.sess.bug(format!("Variable id {} maps to {:?}, not local", id, r)[]); } @@ -4297,7 +4297,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, return match adjustment { Some(adjustment) => { match *adjustment { - AdjustReifyFnPointer(_) => { + AdjustReifyFnPointer(_) => { match unadjusted_ty.sty { ty::ty_bare_fn(Some(_), b) => { ty::mk_bare_fn(cx, None, b) @@ -4305,7 +4305,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, ref b => { cx.sess.bug( format!("AdjustReifyFnPointer adjustment on non-fn-item: \ - {}", + {:?}", b)[]); } } @@ -4396,7 +4396,7 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, mk_vec(cx, ty, None) } _ => cx.sess.span_bug(span, - format!("UnsizeLength with bad sty: {}", + format!("UnsizeLength with bad sty: {:?}", ty_to_string(cx, ty))[]) }, &UnsizeStruct(box ref k, tp_index) => match ty.sty { @@ -4408,7 +4408,7 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, mk_struct(cx, did, cx.mk_substs(unsized_substs)) } _ => cx.sess.span_bug(span, - format!("UnsizeStruct with bad sty: {}", + format!("UnsizeStruct with bad sty: {:?}", ty_to_string(cx, ty))[]) }, &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { @@ -4515,7 +4515,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { def => { tcx.sess.span_bug( expr.span, - format!("uncategorized def for expr {}: {}", + format!("uncategorized def for expr {}: {:?}", expr.id, def)[]); } @@ -4638,7 +4638,7 @@ pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) let mut i = 0u; for f in fields.iter() { if f.name == name { return i; } i += 1u; } tcx.sess.bug(format!( - "no field named `{}` found in the list of fields `{}`", + "no field named `{}` found in the list of fields `{:?}`", token::get_name(name), fields.iter() .map(|f| token::get_name(f.name).get().to_string()) @@ -4715,18 +4715,18 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String { terr_mismatch => "types differ".to_string(), terr_unsafety_mismatch(values) => { format!("expected {} fn, found {} fn", - values.expected.to_string(), - values.found.to_string()) + values.expected, + values.found) } terr_abi_mismatch(values) => { format!("expected {} fn, found {} fn", - values.expected.to_string(), - values.found.to_string()) + values.expected, + values.found) } terr_onceness_mismatch(values) => { format!("expected {} fn, found {} fn", - values.expected.to_string(), - values.found.to_string()) + values.expected, + values.found) } terr_sigil_mismatch(values) => { format!("expected {}, found {}", @@ -4818,14 +4818,14 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String { "expected an integral type, found `char`".to_string() } terr_int_mismatch(ref values) => { - format!("expected `{}`, found `{}`", - values.expected.to_string(), - values.found.to_string()) + format!("expected `{:?}`, found `{:?}`", + values.expected, + values.found) } terr_float_mismatch(ref values) => { - format!("expected `{}`, found `{}`", - values.expected.to_string(), - values.found.to_string()) + format!("expected `{:?}`, found `{:?}`", + values.expected, + values.found) } terr_variadic_mismatch(ref values) => { format!("expected {} fn, found {} function", @@ -4914,14 +4914,14 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) }).collect() } _ => { - cx.sess.bug(format!("provided_trait_methods: `{}` is \ + cx.sess.bug(format!("provided_trait_methods: `{:?}` is \ not a trait", id)[]) } } } _ => { - cx.sess.bug(format!("provided_trait_methods: `{}` is not a \ + cx.sess.bug(format!("provided_trait_methods: `{:?}` is not a \ trait", id)[]) } @@ -4950,7 +4950,7 @@ fn lookup_locally_or_in_crate_store(descr: &str, } if def_id.krate == ast::LOCAL_CRATE { - panic!("No def'n found for {} in tcx.{}", def_id, descr); + panic!("No def'n found for {:?} in tcx.{}", def_id, descr); } let v = load_external(); map.insert(def_id, v.clone()); @@ -5057,7 +5057,7 @@ pub fn impl_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Option>> { memoized(&cx.impl_trait_cache, id, |id: ast::DefId| { if id.krate == ast::LOCAL_CRATE { - debug!("(impl_trait_ref) searching for trait impl {}", id); + debug!("(impl_trait_ref) searching for trait impl {:?}", id); match cx.map.find(id.node) { Some(ast_map::NodeItem(item)) => { match item.node { @@ -5377,7 +5377,7 @@ pub fn predicates_for_trait_ref<'tcx>(tcx: &ctxt<'tcx>, { let trait_def = lookup_trait_def(tcx, trait_ref.def_id()); - debug!("bounds_for_trait_ref(trait_def={}, trait_ref={})", + debug!("bounds_for_trait_ref(trait_def={:?}, trait_ref={:?})", trait_def.repr(tcx), trait_ref.repr(tcx)); // The interaction between HRTB and supertraits is not entirely @@ -5929,7 +5929,7 @@ pub fn required_region_bounds<'tcx>(tcx: &ctxt<'tcx>, predicates: Vec>) -> Vec { - debug!("required_region_bounds(erased_self_ty={}, predicates={})", + debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})", erased_self_ty.repr(tcx), predicates.repr(tcx)); @@ -6007,7 +6007,7 @@ pub fn populate_implementations_for_type_if_necessary(tcx: &ctxt, return } - debug!("populate_implementations_for_type_if_necessary: searching for {}", type_id); + debug!("populate_implementations_for_type_if_necessary: searching for {:?}", type_id); let mut inherent_impls = Vec::new(); csearch::each_implementation_for_type(&tcx.sess.cstore, type_id, @@ -6368,7 +6368,7 @@ pub fn construct_parameter_environment<'a,'tcx>( record_region_bounds(tcx, &bounds); - debug!("construct_parameter_environment: free_id={} free_subst={} bounds={}", + debug!("construct_parameter_environment: free_id={:?} free_subst={:?} bounds={:?}", free_id, free_substs.repr(tcx), bounds.repr(tcx)); @@ -6394,15 +6394,15 @@ pub fn construct_parameter_environment<'a,'tcx>( types: &mut VecPerParamSpace>, defs: &[TypeParameterDef<'tcx>]) { for def in defs.iter() { - debug!("construct_parameter_environment(): push_types_from_defs: def={}", + debug!("construct_parameter_environment(): push_types_from_defs: def={:?}", def.repr(tcx)); let ty = ty::mk_param_from_def(tcx, def); types.push(def.space, ty); - } + } } fn record_region_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, bounds: &GenericBounds<'tcx>) { - debug!("record_region_bounds(bounds={})", bounds.repr(tcx)); + debug!("record_region_bounds(bounds={:?})", bounds.repr(tcx)); for predicate in bounds.predicates.iter() { match *predicate { @@ -6756,7 +6756,7 @@ pub fn replace_late_bound_regions<'tcx, T, F>( } }); - debug!("resulting map: {} value: {}", map, value.repr(tcx)); + debug!("resulting map: {:?} value: {:?}", map, value.repr(tcx)); (value, map) } @@ -6804,7 +6804,7 @@ impl<'tcx> Repr<'tcx> for AutoRef<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { match *self { AutoPtr(a, b, ref c) => { - format!("AutoPtr({},{},{})", a.repr(tcx), b, c.repr(tcx)) + format!("AutoPtr({},{:?},{})", a.repr(tcx), b, c.repr(tcx)) } AutoUnsize(ref a) => { format!("AutoUnsize({})", a.repr(tcx)) @@ -6813,7 +6813,7 @@ impl<'tcx> Repr<'tcx> for AutoRef<'tcx> { format!("AutoUnsizeUniq({})", a.repr(tcx)) } AutoUnsafe(ref a, ref b) => { - format!("AutoUnsafe({},{})", a, b.repr(tcx)) + format!("AutoUnsafe({:?},{})", a, b.repr(tcx)) } } } @@ -6843,7 +6843,7 @@ impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { match *self { vtable_static(def_id, ref tys, ref vtable_res) => { - format!("vtable_static({}:{}, {}, {})", + format!("vtable_static({:?}:{}, {}, {})", def_id, ty::item_path_str(tcx, def_id), tys.repr(tcx), @@ -6851,11 +6851,11 @@ impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> { } vtable_param(x, y) => { - format!("vtable_param({}, {})", x, y) + format!("vtable_param({:?}, {})", x, y) } vtable_unboxed_closure(def_id) => { - format!("vtable_unboxed_closure({})", def_id) + format!("vtable_unboxed_closure({:?})", def_id) } vtable_error => { @@ -7286,7 +7286,7 @@ impl ReferencesError for Region impl<'tcx> Repr<'tcx> for ClosureTy<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - format!("ClosureTy({},{},{},{},{},{})", + format!("ClosureTy({},{},{:?},{},{},{})", self.unsafety, self.onceness, self.store, diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs index 4953e9a2ce1d1..28975c7341659 100644 --- a/src/librustc/middle/ty_walk.rs +++ b/src/librustc/middle/ty_walk.rs @@ -95,7 +95,7 @@ impl<'tcx> Iterator for TypeWalker<'tcx> { type Item = Ty<'tcx>; fn next(&mut self) -> Option> { - debug!("next(): stack={}", self.stack); + debug!("next(): stack={:?}", self.stack); match self.stack.pop() { None => { return None; @@ -103,7 +103,7 @@ impl<'tcx> Iterator for TypeWalker<'tcx> { Some(ty) => { self.last_subtree = self.stack.len(); self.push_subtypes(ty); - debug!("next: stack={}", self.stack); + debug!("next: stack={:?}", self.stack); Some(ty) } } diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index 7d2a8509cb510..26f98e28a8d95 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -64,7 +64,7 @@ pub fn indent(op: F) -> R where // to make debug output more readable. debug!(">>"); let r = op(); - debug!("<< (Result = {})", r); + debug!("<< (Result = {:?})", r); r } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 8c2a9993004d9..73e3c508d943a 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -111,7 +111,7 @@ pub fn explain_region_and_span(cx: &ctxt, region: ty::Region) } Some(_) | None => { // this really should not happen - (format!("unknown scope: {}. Please report a bug.", scope), None) + (format!("unknown scope: {:?}. Please report a bug.", scope), None) } } } @@ -140,7 +140,7 @@ pub fn explain_region_and_span(cx: &ctxt, region: ty::Region) } Some(_) | None => { // this really should not happen - (format!("{} unknown free region bounded by scope {}", prefix, fr.scope), None) + (format!("{} unknown free region bounded by scope {:?}", prefix, fr.scope), None) } } } @@ -156,7 +156,7 @@ pub fn explain_region_and_span(cx: &ctxt, region: ty::Region) // I believe these cases should not occur (except when debugging, // perhaps) ty::ReInfer(_) | ty::ReLateBound(..) => { - (format!("lifetime {}", region), None) + (format!("lifetime {:?}", region), None) } }; @@ -653,13 +653,13 @@ impl<'tcx, T:UserString<'tcx>> UserString<'tcx> for Vec { impl<'tcx> Repr<'tcx> for def::Def { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ty::TypeParameterDef<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - format!("TypeParameterDef({}, {}, {}/{})", + format!("TypeParameterDef({:?}, {}, {:?}/{})", self.def_id, self.bounds.repr(tcx), self.space, @@ -854,7 +854,7 @@ impl<'tcx> Repr<'tcx> for ty::Region { fn repr(&self, tcx: &ctxt) -> String { match *self { ty::ReEarlyBound(id, space, index, name) => { - format!("ReEarlyBound({}, {}, {}, {})", + format!("ReEarlyBound({}, {:?}, {}, {})", id, space, index, @@ -862,7 +862,7 @@ impl<'tcx> Repr<'tcx> for ty::Region { } ty::ReLateBound(binder_id, ref bound_region) => { - format!("ReLateBound({}, {})", + format!("ReLateBound({:?}, {})", binder_id, bound_region.repr(tcx)) } @@ -870,7 +870,7 @@ impl<'tcx> Repr<'tcx> for ty::Region { ty::ReFree(ref fr) => fr.repr(tcx), ty::ReScope(id) => { - format!("ReScope({})", id) + format!("ReScope({:?})", id) } ty::ReStatic => { @@ -878,7 +878,7 @@ impl<'tcx> Repr<'tcx> for ty::Region { } ty::ReInfer(ReVar(ref vid)) => { - format!("{}", vid) + format!("{:?}", vid) } ty::ReInfer(ReSkolemized(id, ref bound_region)) => { @@ -920,14 +920,14 @@ impl<'tcx> Repr<'tcx> for ast::DefId { Some(ast_map::NodeVariant(..)) | Some(ast_map::NodeStructCtor(..)) => { return format!( - "{}:{}", + "{:?}:{}", *self, ty::item_path_str(tcx, *self)) } _ => {} } } - return format!("{}", *self) + return format!("{:?}", *self) } } @@ -1007,13 +1007,13 @@ impl<'tcx> Repr<'tcx> for ast::Ident { impl<'tcx> Repr<'tcx> for ast::ExplicitSelf_ { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ast::Visibility { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } @@ -1026,6 +1026,7 @@ impl<'tcx> Repr<'tcx> for ty::BareFnTy<'tcx> { } } + impl<'tcx> Repr<'tcx> for ty::FnSig<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("fn{} -> {}", self.inputs.repr(tcx), self.output.repr(tcx)) @@ -1096,7 +1097,7 @@ impl<'tcx> Repr<'tcx> for ty::TraitStore { impl<'tcx> Repr<'tcx> for ty::BuiltinBound { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } @@ -1251,13 +1252,13 @@ impl<'tcx> Repr<'tcx> for ty::UpvarId { impl<'tcx> Repr<'tcx> for ast::Mutability { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ty::BorrowKind { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } @@ -1271,49 +1272,49 @@ impl<'tcx> Repr<'tcx> for ty::UpvarBorrow { impl<'tcx> Repr<'tcx> for ty::IntVid { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for ty::FloatVid { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for ty::RegionVid { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for ty::TyVid { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for ty::IntVarValue { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ast::IntTy { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ast::UintTy { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } impl<'tcx> Repr<'tcx> for ast::FloatTy { fn repr(&self, _tcx: &ctxt) -> String { - format!("{}", *self) + format!("{:?}", *self) } } @@ -1332,7 +1333,7 @@ impl<'tcx> UserString<'tcx> for ParamTy { impl<'tcx> Repr<'tcx> for ParamTy { fn repr(&self, tcx: &ctxt) -> String { let ident = self.user_string(tcx); - format!("{}/{}.{}", ident, self.space, self.idx) + format!("{}/{:?}.{}", ident, self.space, self.idx) } } diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index 0bd4265e487a6..3505ecad5d990 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -64,7 +64,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option, match cwd { Some(p) => { cmd.cwd(p); - debug!("inside {}", p.display()); + debug!("inside {:?}", p.display()); } None => {} } @@ -105,7 +105,7 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str, let unixlibname = format!("lib{}.a", name); for path in search_paths.iter() { - debug!("looking for {} inside {}", name, path.display()); + debug!("looking for {} inside {:?}", name, path.display()); let test = path.join(oslibname[]); if test.exists() { return test } if oslibname != unixlibname { diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 955081a3af64c..33d547b647dd9 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -61,10 +61,10 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec F: FnOnce() -> Path, G: FnMut(&Path) -> Result, { - debug!("output: {}", config.out_filename.display()); + debug!("output: {:?}", config.out_filename.display()); debug!("libs:"); for libpath in libs.iter() { - debug!(" {}", libpath.display()); + debug!(" {:?}", libpath.display()); } // Use relative paths to the libraries. Binaries can be moved diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 86bd74d3f85e5..8569f35d3a378 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -119,6 +119,14 @@ impl Svh { } impl fmt::Show for Svh { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + //NOTE(stage0): uncomment after snapshot + //write!(f, "Svh {{ {} }}", self.as_str()) + fmt::String::fmt(self, f) + } +} + +impl fmt::String for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad(self.as_str()) } diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index f14583bb9aa81..f63339b0e7086 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -299,8 +299,8 @@ impl Target { use serialize::json; fn load_file(path: &Path) -> Result { - let mut f = try!(File::open(path).map_err(|e| e.to_string())); - let obj = try!(json::from_reader(&mut f).map_err(|e| e.to_string())); + let mut f = try!(File::open(path).map_err(|e| format!("{:?}", e))); + let obj = try!(json::from_reader(&mut f).map_err(|e| format!("{:?}", e))); Ok(Target::from_json(obj)) } @@ -313,7 +313,7 @@ impl Target { $( else if target == stringify!($name) { let t = $name::target(); - debug!("Got builtin target: {}", t); + debug!("Got builtin target: {:?}", t); return Ok(t); } )* @@ -377,6 +377,6 @@ impl Target { } } - Err(format!("Could not find specification for target {}", target)) + Err(format!("Could not find specification for target {:?}", target)) } } diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index cb77519671cf5..0cfc2984af5e1 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -96,7 +96,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> { consume_span: Span, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) { - debug!("consume(consume_id={}, cmt={}, mode={})", + debug!("consume(consume_id={}, cmt={}, mode={:?})", consume_id, cmt.repr(self.tcx()), mode); self.consume_common(consume_id, consume_span, cmt, mode); @@ -111,7 +111,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> { consume_pat: &ast::Pat, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) { - debug!("consume_pat(consume_pat={}, cmt={}, mode={})", + debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})", consume_pat.repr(self.tcx()), cmt.repr(self.tcx()), mode); @@ -127,8 +127,8 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> { bk: ty::BorrowKind, loan_cause: euv::LoanCause) { - debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \ - bk={}, loan_cause={})", + debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \ + bk={:?}, loan_cause={:?})", borrow_id, cmt.repr(self.tcx()), loan_region, bk, loan_cause); @@ -355,10 +355,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { //! (Note that some loans can be *issued* without necessarily //! taking effect yet.) - debug!("check_for_conflicting_loans(scope={})", scope); + debug!("check_for_conflicting_loans(scope={:?})", scope); let new_loan_indices = self.loans_generated_by(scope); - debug!("new_loan_indices = {}", new_loan_indices); + debug!("new_loan_indices = {:?}", new_loan_indices); self.each_issued_loan(scope, |issued_loan| { for &new_loan_index in new_loan_indices.iter() { @@ -696,7 +696,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { span: Span, use_kind: MovedValueUseKind, lp: &Rc>) { - debug!("check_if_path_is_moved(id={}, use_kind={}, lp={})", + debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={})", id, use_kind, lp.repr(self.bccx.tcx)); let base_lp = owned_ptr_base_path_rc(lp); self.move_data.each_move_of(id, &base_lp, |the_move, moved_lp| { diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 0d86811af9f49..bb4dd79fabe5f 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -198,11 +198,11 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { // First, filter out duplicates moved.sort(); moved.dedup(); - debug!("fragments 1 moved: {}", path_lps(moved[])); + debug!("fragments 1 moved: {:?}", path_lps(moved[])); assigned.sort(); assigned.dedup(); - debug!("fragments 1 assigned: {}", path_lps(assigned[])); + debug!("fragments 1 assigned: {:?}", path_lps(assigned[])); // Second, build parents from the moved and assigned. for m in moved.iter() { @@ -222,14 +222,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { parents.sort(); parents.dedup(); - debug!("fragments 2 parents: {}", path_lps(parents[])); + debug!("fragments 2 parents: {:?}", path_lps(parents[])); // Third, filter the moved and assigned fragments down to just the non-parents moved.retain(|f| non_member(*f, parents[])); - debug!("fragments 3 moved: {}", path_lps(moved[])); + debug!("fragments 3 moved: {:?}", path_lps(moved[])); assigned.retain(|f| non_member(*f, parents[])); - debug!("fragments 3 assigned: {}", path_lps(assigned[])); + debug!("fragments 3 assigned: {:?}", path_lps(assigned[])); // Fourth, build the leftover from the moved, assigned, and parents. for m in moved.iter() { @@ -247,7 +247,7 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { unmoved.sort(); unmoved.dedup(); - debug!("fragments 4 unmoved: {}", frag_lps(unmoved[])); + debug!("fragments 4 unmoved: {:?}", frag_lps(unmoved[])); // Fifth, filter the leftover fragments down to its core. unmoved.retain(|f| match *f { @@ -256,7 +256,7 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { non_member(mpi, moved[]) && non_member(mpi, assigned[]) }); - debug!("fragments 5 unmoved: {}", frag_lps(unmoved[])); + debug!("fragments 5 unmoved: {:?}", frag_lps(unmoved[])); // Swap contents back in. fragments.unmoved_fragments = unmoved; @@ -430,7 +430,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, } ref sty_and_variant_info => { - let msg = format!("type {} ({}) is not fragmentable", + let msg = format!("type {} ({:?}) is not fragmentable", parent_ty.repr(tcx), sty_and_variant_info); let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id)); tcx.sess.opt_span_bug(opt_span, msg[]) diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index 6f02f447a158d..ca1fba53de42a 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -65,7 +65,7 @@ pub fn gather_match_variant<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, cmt: mc::cmt<'tcx>, mode: euv::MatchMode) { let tcx = bccx.tcx; - debug!("gather_match_variant(move_pat={}, cmt={}, mode={})", + debug!("gather_match_variant(move_pat={}, cmt={}, mode={:?})", move_pat.id, cmt.repr(tcx), mode); let opt_lp = opt_loan_path(&cmt); diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index 1e9e5b22aa0ed..4ca46698af37a 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -76,7 +76,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> { _consume_span: Span, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) { - debug!("consume(consume_id={}, cmt={}, mode={})", + debug!("consume(consume_id={}, cmt={}, mode={:?})", consume_id, cmt.repr(self.tcx()), mode); match mode { @@ -93,7 +93,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> { matched_pat: &ast::Pat, cmt: mc::cmt<'tcx>, mode: euv::MatchMode) { - debug!("matched_pat(matched_pat={}, cmt={}, mode={})", + debug!("matched_pat(matched_pat={}, cmt={}, mode={:?})", matched_pat.repr(self.tcx()), cmt.repr(self.tcx()), mode); @@ -109,7 +109,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> { consume_pat: &ast::Pat, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) { - debug!("consume_pat(consume_pat={}, cmt={}, mode={})", + debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})", consume_pat.repr(self.tcx()), cmt.repr(self.tcx()), mode); @@ -132,8 +132,8 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> { bk: ty::BorrowKind, loan_cause: euv::LoanCause) { - debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \ - bk={}, loan_cause={})", + debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \ + bk={:?}, loan_cause={:?})", borrow_id, cmt.repr(self.tcx()), loan_region, bk, loan_cause); @@ -235,7 +235,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { loan_region: ty::Region, cause: euv::LoanCause) { debug!("guarantee_valid(borrow_id={}, cmt={}, \ - req_mutbl={}, loan_region={})", + req_mutbl={:?}, loan_region={:?})", borrow_id, cmt.repr(self.tcx()), req_kind, @@ -273,7 +273,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { self.bccx, borrow_span, cause, cmt.clone(), loan_region); - debug!("guarantee_valid(): restrictions={}", restr); + debug!("guarantee_valid(): restrictions={:?}", restr); // Create the loan record (if needed). let loan = match restr { @@ -306,18 +306,18 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { ty::ReInfer(..) => { self.tcx().sess.span_bug( cmt.span, - format!("invalid borrow lifetime: {}", + format!("invalid borrow lifetime: {:?}", loan_region)[]); } }; - debug!("loan_scope = {}", loan_scope); + debug!("loan_scope = {:?}", loan_scope); let borrow_scope = region::CodeExtent::from_node_id(borrow_id); let gen_scope = self.compute_gen_scope(borrow_scope, loan_scope); - debug!("gen_scope = {}", gen_scope); + debug!("gen_scope = {:?}", gen_scope); let kill_scope = self.compute_kill_scope(loan_scope, &*loan_path); - debug!("kill_scope = {}", kill_scope); + debug!("kill_scope = {:?}", kill_scope); if req_kind == ty::MutBorrow { self.mark_loan_path_as_mutated(&*loan_path); diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 20949151557cb..ff958a0443041 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -586,7 +586,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } r => { self.tcx.sess.bug(format!("MoveExpr({}) maps to \ - {}, not Expr", + {:?}, not Expr", the_move.id, r)[]) } @@ -624,7 +624,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } r => { self.tcx.sess.bug(format!("Captured({}) maps to \ - {}, not Expr", + {:?}, not Expr", the_move.id, r)[]) } @@ -1005,7 +1005,7 @@ impl DataFlowOperator for LoanDataFlowOperator { impl<'tcx> Repr<'tcx> for Loan<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { - format!("Loan_{}({}, {}, {}-{}, {})", + format!("Loan_{}({}, {:?}, {:?}-{:?}, {})", self.index, self.loan_path.repr(tcx), self.kind, diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index b49164f0c2547..21b3c910d328a 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -311,7 +311,7 @@ impl<'tcx> MoveData<'tcx> { } }; - debug!("move_path(lp={}, index={})", + debug!("move_path(lp={}, index={:?})", lp.repr(tcx), index); @@ -362,7 +362,7 @@ impl<'tcx> MoveData<'tcx> { lp: Rc>, id: ast::NodeId, kind: MoveKind) { - debug!("add_move(lp={}, id={}, kind={})", + debug!("add_move(lp={}, id={}, kind={:?})", lp.repr(tcx), id, kind); @@ -413,12 +413,12 @@ impl<'tcx> MoveData<'tcx> { }; if self.is_var_path(path_index) { - debug!("add_assignment[var](lp={}, assignment={}, path_index={})", + debug!("add_assignment[var](lp={}, assignment={}, path_index={:?})", lp.repr(tcx), self.var_assignments.borrow().len(), path_index); self.var_assignments.borrow_mut().push(assignment); } else { - debug!("add_assignment[path](lp={}, path_index={})", + debug!("add_assignment[path](lp={}, path_index={:?})", lp.repr(tcx), path_index); self.path_assignments.borrow_mut().push(assignment); diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index f2c35851d0d7c..4f5f55edf8567 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -53,7 +53,7 @@ pub struct DataflowLabeller<'a, 'tcx: 'a> { impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { fn dataflow_for(&self, e: EntryOrExit, n: &Node<'a>) -> String { let id = n.1.data.id; - debug!("dataflow_for({}, id={}) {}", e, id, self.variants); + debug!("dataflow_for({:?}, id={}) {:?}", e, id, self.variants); let mut sets = "".to_string(); let mut seen_one = false; for &variant in self.variants.iter() { diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 74f81ae9d6d1e..4851183fb7017 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -726,7 +726,7 @@ pub fn collect_crate_types(session: &Session, let res = !link::invalid_output_for_target(session, *crate_type); if !res { - session.warn(format!("dropping unsupported crate type `{}` \ + session.warn(format!("dropping unsupported crate type `{:?}` \ for target `{}`", *crate_type, session.opts.target_triple)[]); } diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 61fd7d16ab7dd..223dc40bb370c 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -548,7 +548,7 @@ pub fn pretty_print_input(sess: Session, (PpmSource(s), None) => s.call_with_pp_support( sess, ast_map, &arenas, id, out, |annotation, out| { - debug!("pretty printing source code {}", s); + debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); pprust::print_crate(sess.codemap(), sess.diagnostic(), @@ -563,7 +563,7 @@ pub fn pretty_print_input(sess: Session, (PpmSource(s), Some(uii)) => s.call_with_pp_support( sess, ast_map, &arenas, id, (out,uii), |annotation, (out,uii)| { - debug!("pretty printing source code {}", s); + debug!("pretty printing source code {:?}", s); let sess = annotation.sess(); let ast_map = annotation.ast_map() .expect("--pretty missing ast_map"); @@ -586,7 +586,7 @@ pub fn pretty_print_input(sess: Session, }), (PpmFlowGraph, opt_uii) => { - debug!("pretty printing flow graph for {}", opt_uii); + debug!("pretty printing flow graph for {:?}", opt_uii); let uii = opt_uii.unwrap_or_else(|| { sess.fatal(format!("`pretty flowgraph=..` needs NodeId (int) or unique path suffix (b::c::d)")[]) @@ -609,7 +609,7 @@ pub fn pretty_print_input(sess: Session, } None => { let message = format!("--pretty=flowgraph needs \ - block, fn, or method; got {}", + block, fn, or method; got {:?}", node); // point to what was found, if there's an diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 10788f9f7cb83..6039b9d40810b 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -845,7 +845,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { name: Name, new_parent: &Rc) { debug!("(building reduced graph for \ - external crate) building external def, priv {}", + external crate) building external def, priv {:?}", vis); let is_public = vis == ast::Public; let modifiers = if is_public { PUBLIC } else { DefModifiers::empty() } | IMPORTABLE; @@ -989,7 +989,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { DefLocal(..) | DefPrimTy(..) | DefTyParam(..) | DefUse(..) | DefUpvar(..) | DefRegion(..) | DefTyParamBinder(..) | DefLabel(..) | DefSelfTy(..) => { - panic!("didn't expect `{}`", def); + panic!("didn't expect `{:?}`", def); } } } diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 26b1058d18341..18066a7b94bd8 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -58,7 +58,7 @@ impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> { // public or private item, we will check the correct thing, dependent on how the import // is used. fn finalize_import(&mut self, id: ast::NodeId, span: Span) { - debug!("finalizing import uses for {}", + debug!("finalizing import uses for {:?}", self.session.codemap().span_to_snippet(span)); if !self.used_imports.contains(&(id, TypeNS)) && diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 58102fe5629d9..8142736ea2541 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -548,7 +548,7 @@ impl Module { impl fmt::Show for Module { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}, kind: {}, {}", + write!(f, "{:?}, kind: {:?}, {}", self.def_id, self.kind, if self.is_public { "public" } else { "private" } ) @@ -689,7 +689,7 @@ impl NameBindings { /// Records a type definition. fn define_type(&self, def: Def, sp: Span, modifiers: DefModifiers) { - debug!("defining type for def {} with modifiers {}", def, modifiers); + debug!("defining type for def {:?} with modifiers {:?}", def, modifiers); // Merges the type with the existing type def or creates a new one. let type_def = self.type_def.borrow().clone(); match type_def { @@ -714,7 +714,7 @@ impl NameBindings { /// Records a value definition. fn define_value(&self, def: Def, sp: Span, modifiers: DefModifiers) { - debug!("defining value for def {} with modifiers {}", def, modifiers); + debug!("defining value for def {:?} with modifiers {:?}", def, modifiers); *self.value_def.borrow_mut() = Some(ValueNsDef { def: def, value_span: Some(sp), @@ -1272,7 +1272,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { lp: LastPrivate) -> ResolveResult<()> { debug!("(resolving single import) resolving `{}` = `{}::{}` from \ - `{}` id {}, last private {}", + `{}` id {}, last private {:?}", token::get_name(target), self.module_to_string(&*containing_module), token::get_name(source), @@ -1375,7 +1375,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { shadowable: _ }) => { debug!("(resolving single import) found \ - import in ns {}", namespace); + import in ns {:?}", namespace); let id = import_resolution.id(namespace); // track used imports and extern crates as well this.used_imports.insert((id, namespace)); @@ -1484,7 +1484,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match *result { BoundResult(ref target_module, ref name_bindings) => { - debug!("(resolving single import) found {} target: {}", + debug!("(resolving single import) found {:?} target: {:?}", namespace_name, name_bindings.def_for_namespace(namespace)); self.check_for_conflicting_import( @@ -1508,7 +1508,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } UnboundResult => { /* Continue. */ } UnknownResult => { - panic!("{} result should be known at this point", namespace_name); + panic!("{:?} result should be known at this point", namespace_name); } } }; @@ -2165,7 +2165,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { namespace: Namespace) -> ResolveResult<(Target, bool)> { debug!("(resolving item in lexical scope) resolving `{}` in \ - namespace {} in `{}`", + namespace {:?} in `{}`", token::get_name(name), namespace, self.module_to_string(&*module_)); @@ -2195,7 +2195,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { // Not found; continue. debug!("(resolving item in lexical scope) found \ - import resolution, but not in namespace {}", + import resolution, but not in namespace {:?}", namespace); } Some(target) => { @@ -2475,7 +2475,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match import_resolution.target_for_namespace(namespace) { None => { debug!("(resolving name in module) name found, \ - but not in namespace {}", + but not in namespace {:?}", namespace); } Some(target) => { @@ -2620,7 +2620,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match def_like { DlDef(d @ DefUpvar(..)) => { self.session.span_bug(span, - format!("unexpected {} in bindings", d)[]) + format!("unexpected {:?} in bindings", d)[]) } DlDef(d @ DefLocal(_)) => { let node_id = d.def_id().node; @@ -3187,7 +3187,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(def) => { match def { (DefTrait(_), _) => { - debug!("(resolving trait) found trait def: {}", def); + debug!("(resolving trait) found trait def: {:?}", def); self.record_def(trait_reference.ref_id, def); } (def, _) => { @@ -3578,8 +3578,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { match self.resolve_path(ty.id, path, TypeNS, true) { Some(def) => { - debug!("(resolving type) resolved `{}` to \ - type {}", + debug!("(resolving type) resolved `{:?}` to \ + type {:?}", token::get_ident(path.segments.last().unwrap() .identifier), def); result_def = Some(def); @@ -3797,7 +3797,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } result => { debug!("(resolving pattern) didn't find struct \ - def: {}", result); + def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); self.resolve_error(path.span, msg[]); @@ -3821,7 +3821,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ValueNS) { Success((target, _)) => { debug!("(resolve bare identifier pattern) succeeded in \ - finding {} at {}", + finding {} at {:?}", token::get_name(name), target.bindings.value_def.borrow()); match *target.bindings.value_def.borrow() { @@ -4179,7 +4179,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { match search_result { Some(DlDef(def)) => { debug!("(resolving path in local ribs) resolved `{}` to \ - local: {}", + local: {:?}", token::get_ident(ident), def); return Some(def); @@ -4530,7 +4530,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { Some(definition) => self.record_def(expr.id, definition), result => { debug!("(resolving expression) didn't find struct \ - def: {}", result); + def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_names_to_string(path)); self.resolve_error(path.span, msg[]); @@ -4717,7 +4717,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn record_def(&mut self, node_id: NodeId, (def, lp): (Def, LastPrivate)) { - debug!("(recording def) recording {} for {}, last private {}", + debug!("(recording def) recording {:?} for {}, last private {:?}", def, node_id, lp); assert!(match lp {LastImport{..} => false, _ => true}, "Import should only be used for `use` directives"); @@ -4729,8 +4729,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // the same conclusion! - nmatsakis Occupied(entry) => if def != *entry.get() { self.session - .bug(format!("node_id {} resolved first to {} and \ - then {}", + .bug(format!("node_id {} resolved first to {:?} and \ + then {:?}", node_id, *entry.get(), def)[]); diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 84fd3c936719b..67bcf152eb78c 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -117,7 +117,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { ns: Namespace) { match namebindings.def_for_namespace(ns) { Some(d) => { - debug!("(computing exports) YES: export '{}' => {}", + debug!("(computing exports) YES: export '{}' => {:?}", name, d.def_id()); exports.push(Export { name: name, @@ -125,7 +125,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { }); } d_opt => { - debug!("(computing exports) NO: {}", d_opt); + debug!("(computing exports) NO: {:?}", d_opt); } } } diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 8fbeadc55b387..d990842eefd19 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -171,7 +171,7 @@ pub fn build_link_meta(sess: &Session, krate: &ast::Crate, crate_name: name, crate_hash: Svh::calculate(&sess.opts.cg.metadata, krate), }; - info!("{}", r); + info!("{:?}", r); return r; } @@ -373,7 +373,7 @@ pub fn link_binary(sess: &Session, let mut out_filenames = Vec::new(); for &crate_type in sess.crate_types.borrow().iter() { if invalid_output_for_target(sess, crate_type) { - sess.bug(format!("invalid output type `{}` for target os `{}`", + sess.bug(format!("invalid output type `{:?}` for target os `{}`", crate_type, sess.opts.target_triple)[]); } let out_file = link_binary_output(sess, trans, crate_type, outputs, diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 98e2b4b9dddb5..84d42366efe99 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -174,7 +174,7 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { "default" => llvm::RelocDefault, "dynamic-no-pic" => llvm::RelocDynamicNoPic, _ => { - sess.err(format!("{} is not a valid relocation mode", + sess.err(format!("{:?} is not a valid relocation mode", sess.opts .cg .relocation_model)[]); @@ -209,7 +209,7 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { "medium" => llvm::CodeModelMedium, "large" => llvm::CodeModelLarge, _ => { - sess.err(format!("{} is not a valid code model", + sess.err(format!("{:?} is not a valid code model", sess.opts .cg .code_model)[]); diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 8e6276b61f949..0ed01725a6085 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -240,7 +240,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { def::DefUse(_) | def::DefMethod(..) | def::DefPrimTy(_) => { - self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {}", + self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {:?}", def)[]); }, } @@ -308,7 +308,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { }, _ => { self.sess.span_bug(method.span, - format!("Container {} for method {} is not a node item {}", + format!("Container {} for method {} is not a node item {:?}", impl_id.node, method.id, self.analysis.ty_cx.map.get(impl_id.node) @@ -1443,7 +1443,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { // FIXME(nrc) what are these doing here? def::DefStatic(_, _) => {} def::DefConst(..) => {} - _ => error!("unexpected definition kind when processing collected paths: {}", *def) + _ => error!("unexpected definition kind when processing collected paths: {:?}", + *def) } } for &(id, span, ref path, ref_kind) in paths_to_process.iter() { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index fed0931cab71d..e1aa3a16d58c9 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -518,7 +518,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>( variant_size: uint, val: ValueRef) -> Vec> { - debug!("enter_opt(bcx={}, m={}, opt={}, col={}, val={})", + debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), *opt, @@ -1046,7 +1046,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, // Decide what kind of branch we need let opts = get_branches(bcx, m, col); - debug!("options={}", opts); + debug!("options={:?}", opts); let mut kind = NoBranch; let mut test_val = val; debug!("test_val={}", bcx.val_to_string(test_val)); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 01b47b728b6ba..05cd54705ca5a 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -145,7 +145,7 @@ pub fn represent_type<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } let repr = Rc::new(represent_type_uncached(cx, t)); - debug!("Represented as: {}", repr); + debug!("Represented as: {:?}", repr); cx.adt_reprs().borrow_mut().insert(t, repr.clone()); repr } @@ -482,7 +482,7 @@ fn mk_cenum<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType { - debug!("range_to_inttype: {} {}", hint, bounds); + debug!("range_to_inttype: {:?} {:?}", hint, bounds); // Lists of sizes to try. u64 is always allowed as a fallback. #[allow(non_upper_case_globals)] static choose_shortest: &'static[IntType] = &[ @@ -533,7 +533,7 @@ pub fn ll_inttype(cx: &CrateContext, ity: IntType) -> Type { } fn bounds_usable(cx: &CrateContext, ity: IntType, bounds: &IntBounds) -> bool { - debug!("bounds_usable: {} {}", ity, bounds); + debug!("bounds_usable: {:?} {:?}", ity, bounds); match ity { attr::SignedInt(_) => { let lllo = C_integral(ll_inttype(cx, ity), bounds.slo as u64, true); @@ -731,7 +731,7 @@ pub fn trans_get_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, -> ValueRef { let signed; let val; - debug!("trans_get_discr r: {}", r); + debug!("trans_get_discr r: {:?}", r); match *r { CEnum(ity, min, max) => { val = load_discr(bcx, ity, scrutinee, min, max); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index edcfaae0f802d..2909da3b3afd0 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -976,7 +976,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } if need_invoke(bcx) { - debug!("invoking {} at {}", bcx.val_to_string(llfn), bcx.llbb); + debug!("invoking {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); for &llarg in llargs.iter() { debug!("arg: {}", bcx.val_to_string(llarg)); } @@ -996,7 +996,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, Some(attributes)); return (llresult, normal_bcx); } else { - debug!("calling {} at {}", bcx.val_to_string(llfn), bcx.llbb); + debug!("calling {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); for &llarg in llargs.iter() { debug!("arg: {}", bcx.val_to_string(llarg)); } @@ -2738,7 +2738,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } let item = ccx.tcx().map.get(id); - debug!("get_item_val: id={} item={}", id, item); + debug!("get_item_val: id={} item={:?}", id, item); let val = match item { ast_map::NodeItem(i) => { let ty = ty::node_id_to_type(ccx.tcx(), i.id); @@ -2913,7 +2913,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } ref variant => { - ccx.sess().bug(format!("get_item_val(): unexpected variant: {}", + ccx.sess().bug(format!("get_item_val(): unexpected variant: {:?}", variant)[]) } }; diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 65e6d7e1924b6..652d4b4516ed9 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -206,7 +206,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) def::DefSelfTy(..) | def::DefAssociatedPath(..) => { bcx.tcx().sess.span_bug( ref_expr.span, - format!("cannot translate def {} \ + format!("cannot translate def {:?} \ to a callable thing!", def)[]); } } @@ -223,7 +223,7 @@ pub fn trans_fn_ref<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let _icx = push_ctxt("trans_fn_ref"); let substs = node_id_substs(ccx, node, param_substs); - debug!("trans_fn_ref(def_id={}, node={}, substs={})", + debug!("trans_fn_ref(def_id={}, node={:?}, substs={})", def_id.repr(ccx.tcx()), node, substs.repr(ccx.tcx())); @@ -386,7 +386,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( let _icx = push_ctxt("trans_fn_ref_with_substs"); let tcx = ccx.tcx(); - debug!("trans_fn_ref_with_substs(def_id={}, node={}, \ + debug!("trans_fn_ref_with_substs(def_id={}, node={:?}, \ param_substs={}, substs={})", def_id.repr(tcx), node, diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 79a5898e3d33e..70ca175bd76a8 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -229,7 +229,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { bcx: Block<'blk, 'tcx>, custom_scope: CustomScopeIndex) -> Block<'blk, 'tcx> { - debug!("pop_and_trans_custom_cleanup_scope({})", custom_scope); + debug!("pop_and_trans_custom_cleanup_scope({:?})", custom_scope); assert!(self.is_valid_to_pop_custom_scope(custom_scope)); let scope = self.pop_scope(); @@ -267,7 +267,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { ptr: val, }; - debug!("schedule_lifetime_end({}, val={})", + debug!("schedule_lifetime_end({:?}, val={})", cleanup_scope, self.ccx.tn().val_to_string(val)); @@ -288,7 +288,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { zero: false }; - debug!("schedule_drop_mem({}, val={}, ty={})", + debug!("schedule_drop_mem({:?}, val={}, ty={})", cleanup_scope, self.ccx.tn().val_to_string(val), ty.repr(self.ccx.tcx())); @@ -310,7 +310,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { zero: true }; - debug!("schedule_drop_and_zero_mem({}, val={}, ty={}, zero={})", + debug!("schedule_drop_and_zero_mem({:?}, val={}, ty={}, zero={})", cleanup_scope, self.ccx.tn().val_to_string(val), ty.repr(self.ccx.tcx()), @@ -334,7 +334,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { zero: false }; - debug!("schedule_drop_immediate({}, val={}, ty={})", + debug!("schedule_drop_immediate({:?}, val={}, ty={:?})", cleanup_scope, self.ccx.tn().val_to_string(val), ty.repr(self.ccx.tcx())); @@ -350,7 +350,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { content_ty: Ty<'tcx>) { let drop = box FreeValue { ptr: val, heap: heap, content_ty: content_ty }; - debug!("schedule_free_value({}, val={}, heap={})", + debug!("schedule_free_value({:?}, val={}, heap={:?})", cleanup_scope, self.ccx.tn().val_to_string(val), heap); @@ -367,7 +367,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { heap: Heap) { let drop = box FreeSlice { ptr: val, size: size, align: align, heap: heap }; - debug!("schedule_free_slice({}, val={}, heap={})", + debug!("schedule_free_slice({:?}, val={}, heap={:?})", cleanup_scope, self.ccx.tn().val_to_string(val), heap); @@ -551,7 +551,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx fn trans_cleanups_to_exit_scope(&'blk self, label: EarlyExitLabel) -> BasicBlockRef { - debug!("trans_cleanups_to_exit_scope label={} scopes={}", + debug!("trans_cleanups_to_exit_scope label={:?} scopes={}", label, self.scopes_len()); let orig_scopes_len = self.scopes_len(); @@ -677,7 +677,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx self.push_scope(scope); } - debug!("trans_cleanups_to_exit_scope: prev_llbb={}", prev_llbb); + debug!("trans_cleanups_to_exit_scope: prev_llbb={:?}", prev_llbb); assert_eq!(self.scopes_len(), orig_scopes_len); prev_llbb @@ -1020,7 +1020,7 @@ pub fn temporary_scope(tcx: &ty::ctxt, match tcx.region_maps.temporary_scope(id) { Some(scope) => { let r = AstScope(scope.node_id()); - debug!("temporary_scope({}) = {}", id, r); + debug!("temporary_scope({}) = {:?}", id, r); r } None => { @@ -1034,7 +1034,7 @@ pub fn var_scope(tcx: &ty::ctxt, id: ast::NodeId) -> ScopeId { let r = AstScope(tcx.region_maps.var_scope(id).node_id()); - debug!("var_scope({}) = {}", id, r); + debug!("var_scope({}) = {:?}", id, r); r } diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index 6f2def16e7674..b5791a72ed61b 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -108,7 +108,7 @@ pub struct EnvValue<'tcx> { impl<'tcx> EnvValue<'tcx> { pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String { - format!("{}({})", self.action, self.datum.to_string(ccx)) + format!("{:?}({})", self.action, self.datum.to_string(ccx)) } } @@ -495,7 +495,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext set_inline_hint(llfn); debug!("get_or_create_declaration_if_unboxed_closure(): inserting new \ - closure {} (type {})", + closure {:?} (type {})", mono_id, ccx.tn().type_to_string(val_ty(llfn))); ccx.unboxed_closure_vals().borrow_mut().insert(mono_id, llfn); diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 094f98e988aad..83b81ce4c6e7b 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -866,7 +866,7 @@ pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint]) unsafe { let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint); - debug!("const_get_elt(v={}, us={}, r={})", + debug!("const_get_elt(v={}, us={:?}, r={})", cx.tn().val_to_string(v), us, cx.tn().val_to_string(r)); return r; @@ -1108,7 +1108,7 @@ pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }; if substs.types.any(|t| ty::type_needs_infer(*t)) { - tcx.sess.bug(format!("type parameters for node {} include inference types: {}", + tcx.sess.bug(format!("type parameters for node {:?} include inference types: {}", node, substs.repr(tcx))[]); } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index a3861e71d83de..991705e3b653f 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -32,7 +32,7 @@ use syntax::ptr::P; pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) -> ValueRef { let _icx = push_ctxt("trans_lit"); - debug!("const_lit: {}", lit); + debug!("const_lit: {:?}", lit); match lit.node { ast::LitByte(b) => C_integral(Type::uint_from_ty(cx, ast::TyU8), b as u64, false), ast::LitChar(i) => C_integral(Type::char(cx), i as u64, false), @@ -187,7 +187,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) None => { } Some(adj) => { match adj { - ty::AdjustReifyFnPointer(_def_id) => { + ty::AdjustReifyFnPointer(_def_id) => { // FIXME(#19925) once fn item types are // zero-sized, we'll need to do something here } @@ -259,7 +259,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) cx.sess() .span_bug(e.span, format!("unimplemented const \ - autoref {}", + autoref {:?}", autoref)[]) } } diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index 768de89d5935d..d9f2cf8e9288f 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -436,7 +436,7 @@ pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match bcx.tcx().def_map.borrow().get(&expr_id) { Some(&def::DefLabel(loop_id)) => loop_id, ref r => { - bcx.tcx().sess.bug(format!("{} in def-map for label", + bcx.tcx().sess.bug(format!("{:?} in def-map for label", r)[]) } } diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index d73b3f6b4e420..c315e1cdb87b0 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -552,7 +552,7 @@ impl<'tcx, K: KindOps + fmt::Show> Datum<'tcx, K> { #[allow(dead_code)] // useful for debugging pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String { - format!("Datum({}, {}, {})", + format!("Datum({}, {}, {:?})", ccx.tn().val_to_string(self.val), ty_to_string(ccx.tcx(), self.ty), self.kind) diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 3f0f7fd9bd303..c33315fd0ef30 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -473,7 +473,7 @@ impl<'tcx> TypeMap<'tcx> { &mut unique_type_id); }, _ => { - cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {}", + cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}", ppaux::ty_to_string(cx.tcx(), type_)[], type_.sty)[]) } @@ -798,14 +798,14 @@ pub fn create_global_var_metadata(cx: &CrateContext, format!("debuginfo::\ create_global_var_metadata() - Captured var-id refers to \ - unexpected ast_item variant: {}", + unexpected ast_item variant: {:?}", var_item)[]) } } }, _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \ - Captured var-id refers to unexpected \ - ast_map variant: {}", + ast_map variant: {:?}", var_item)[]) }; @@ -914,7 +914,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, format!( "debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ - ast_map variant: {}", + ast_map variant: {:?}", ast_item)[]); } } @@ -924,7 +924,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, .span_bug(span, format!("debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ - ast_map variant: {}", + ast_map variant: {:?}", ast_item)[]); } }; @@ -1321,7 +1321,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, _ => { cx.sess() .bug(format!("create_function_debug_context: \ - unexpected sort of node: {}", + unexpected sort of node: {:?}", fnitem)[]) } } @@ -1332,7 +1332,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, return FunctionDebugContext::FunctionWithoutDebugInfo; } _ => cx.sess().bug(format!("create_function_debug_context: \ - unexpected sort of node: {}", + unexpected sort of node: {:?}", fnitem)[]) }; @@ -1615,7 +1615,7 @@ fn compile_unit_metadata(cx: &CrateContext) -> DIDescriptor { } }; - debug!("compile_unit_metadata: {}", compile_unit_name); + debug!("compile_unit_metadata: {:?}", compile_unit_name); let producer = format!("rustc version {}", (option_env!("CFG_VERSION")).expect("CFG_VERSION")); @@ -1769,7 +1769,7 @@ fn scope_metadata(fcx: &FunctionContext, let node = fcx.ccx.tcx().map.get(node_id); fcx.ccx.sess().span_bug(error_reporting_span, - format!("debuginfo: Could not find scope info for node {}", + format!("debuginfo: Could not find scope info for node {:?}", node)[]); } } @@ -1789,7 +1789,7 @@ fn diverging_type_metadata(cx: &CrateContext) -> DIType { fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> DIType { - debug!("basic_type_metadata: {}", t); + debug!("basic_type_metadata: {:?}", t); let (name, encoding) = match t.sty { ty::ty_tup(ref elements) if elements.is_empty() => @@ -2931,7 +2931,7 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } }; - debug!("type_metadata: {}", t); + debug!("type_metadata: {:?}", t); let sty = &t.sty; let MetadataCreationResult { metadata, already_stored_in_typemap } = match *sty { @@ -3011,7 +3011,7 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, usage_site_span).finalize(cx) } _ => { - cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {}", + cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {:?}", sty)[]) } }; @@ -4022,7 +4022,7 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc node, None => { cx.sess().bug(format!("debuginfo::namespace_for_item(): \ - path too short for {}", + path too short for {:?}", def_id)[]); } } diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 9221ae09df98a..518639ba2763c 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -306,7 +306,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // FIXME(#19596) workaround: `|t| t` causes monomorphization recursion fn identity(t: T) -> T { t } - debug!("unsized_info(kind={}, id={}, unadjusted_ty={})", + debug!("unsized_info(kind={:?}, id={}, unadjusted_ty={})", kind, id, unadjusted_ty.repr(bcx.tcx())); match kind { &ty::UnsizeLength(len) => C_uint(bcx.ccx(), len), @@ -656,7 +656,7 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.tcx().sess.span_bug( expr.span, format!("trans_rvalue_datum_unadjusted reached \ - fall-through case: {}", + fall-through case: {:?}", expr.node)[]); } } @@ -1005,7 +1005,7 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.tcx().sess.span_bug( expr.span, format!("trans_rvalue_stmt_unadjusted reached \ - fall-through case: {}", + fall-through case: {:?}", expr.node)[]); } } @@ -1210,7 +1210,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.tcx().sess.span_bug( expr.span, format!("trans_rvalue_dps_unadjusted reached fall-through \ - case: {}", + case: {:?}", expr.node)[]); } } @@ -1260,7 +1260,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } _ => { bcx.tcx().sess.span_bug(ref_expr.span, format!( - "Non-DPS def {} referened by {}", + "Non-DPS def {:?} referened by {}", def, bcx.node_id_to_string(ref_expr.id))[]); } } @@ -1288,7 +1288,7 @@ pub fn trans_def_fn_unadjusted<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } _ => { ccx.tcx().sess.span_bug(ref_expr.span, format!( - "trans_def_fn_unadjusted invoked on: {} for {}", + "trans_def_fn_unadjusted invoked on: {:?} for {}", def, ref_expr.repr(ccx.tcx()))[]); } @@ -1329,7 +1329,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } _ => { bcx.sess().unimpl(format!( - "unsupported def type in trans_local_var: {}", + "unsupported def type in trans_local_var: {:?}", def)[]); } } @@ -2074,7 +2074,7 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out), _ => { ccx.sess().bug(format!("translating unsupported cast: \ - {} ({}) -> {} ({})", + {} ({:?}) -> {} ({:?})", t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), @@ -2083,7 +2083,7 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } } _ => ccx.sess().bug(format!("translating unsupported cast: \ - {} ({}) -> {} ({})", + {} ({:?}) -> {} ({:?})", t_in.repr(bcx.tcx()), k_in, t_out.repr(bcx.tcx()), @@ -2169,7 +2169,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, -> DatumBlock<'blk, 'tcx, Expr> { let ccx = bcx.ccx(); - debug!("deref_once(expr={}, datum={}, method_call={})", + debug!("deref_once(expr={}, datum={}, method_call={:?})", expr.repr(bcx.tcx()), datum.to_string(ccx), method_call); @@ -2253,7 +2253,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } }; - debug!("deref_once(expr={}, method_call={}, result={})", + debug!("deref_once(expr={}, method_call={:?}, result={})", expr.id, method_call, r.datum.to_string(ccx)); return r; diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index f6d69959dadf9..52b65a35b0d69 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -135,7 +135,7 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }) => { let trait_ref = ty::Binder(bcx.monomorphize(trait_ref)); let span = bcx.tcx().map.span(method_call.expr_id); - debug!("method_call={} trait_ref={}", + debug!("method_call={:?} trait_ref={}", method_call, trait_ref.repr(bcx.tcx())); let origin = fulfill_obligation(bcx.ccx(), @@ -177,7 +177,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let _icx = push_ctxt("meth::trans_static_method_callee"); let tcx = ccx.tcx(); - debug!("trans_static_method_callee(method_id={}, trait_id={}, \ + debug!("trans_static_method_callee(method_id={:?}, trait_id={}, \ expr_id={})", method_id, ty::item_path_str(tcx, trait_id), @@ -201,7 +201,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } else { csearch::get_item_path(tcx, method_id).last().unwrap().name() }; - debug!("trans_static_method_callee: method_id={}, expr_id={}, \ + debug!("trans_static_method_callee: method_id={:?}, expr_id={}, \ name={}", method_id, expr_id, token::get_name(mname)); // Find the substitutions for the fn itself. This includes diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index e6db462a342da..ba7e2c907b3a7 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -42,7 +42,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("monomorphic_fn(\ fn_id={}, \ real_substs={}, \ - ref_id={})", + ref_id={:?})", fn_id.repr(ccx.tcx()), psubsts.repr(ccx.tcx()), ref_id); @@ -73,7 +73,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("monomorphic_fn(\ fn_id={}, \ psubsts={}, \ - hash_id={})", + hash_id={:?})", fn_id.repr(ccx.tcx()), psubsts.repr(ccx.tcx()), hash_id); @@ -83,7 +83,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.sess(), ccx.tcx().map.find(fn_id.node), || { - format!("while monomorphizing {}, couldn't find it in \ + format!("while monomorphizing {:?}, couldn't find it in \ the item map (may have attempted to monomorphize \ an item defined in a different crate?)", fn_id) @@ -249,7 +249,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, d } _ => { - ccx.sess().bug(format!("can't monomorphize a {}", + ccx.sess().bug(format!("can't monomorphize a {:?}", map_node)[]) } } @@ -275,7 +275,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ast_map::NodeBlock(..) | ast_map::NodePat(..) | ast_map::NodeLocal(..) => { - ccx.sess().bug(format!("can't monomorphize a {}", + ccx.sess().bug(format!("can't monomorphize a {:?}", map_node)[]) } }; diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 3e499ea8498fb..4ffe2637bd70a 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -277,7 +277,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { None => () } - debug!("type_of {} {}", t.repr(cx.tcx()), t.sty); + debug!("type_of {} {:?}", t.repr(cx.tcx()), t.sty); // Replace any typedef'd types with their equivalent non-typedef // type. This ensures that all LLVM nominal types that contain @@ -288,7 +288,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { if t != t_norm { let llty = type_of(cx, t_norm); - debug!("--> normalized {} {} to {} {} llty={}", + debug!("--> normalized {} {:?} to {} {:?} llty={}", t.repr(cx.tcx()), t, t_norm.repr(cx.tcx()), @@ -407,7 +407,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { ty::ty_err(..) => cx.sess().bug("type_of with ty_err"), }; - debug!("--> mapped t={} {} to llty={}", + debug!("--> mapped t={} {:?} to llty={}", t.repr(cx.tcx()), t, cx.tn().type_to_string(llty)); @@ -457,7 +457,7 @@ pub fn llvm_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let tstr = if strings.is_empty() { base } else { - format!("{}<{}>", base, strings) + format!("{}<{:?}>", base, strings) }; if did.krate == 0 { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 183b8c5c830ef..91e15c4818aa8 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -570,7 +570,7 @@ fn ast_path_to_trait_ref<'a,'tcx>( mut projections: Option<&mut Vec>>) -> Rc> { - debug!("ast_path_to_trait_ref {}", path); + debug!("ast_path_to_trait_ref {:?}", path); let trait_def = this.get_trait_def(trait_def_id); // the trait reference introduces a binding level here, so @@ -1180,7 +1180,7 @@ pub fn ast_ty_to_ty<'tcx>( _ => { tcx.sess.span_fatal(ast_ty.span, format!("found value name used \ - as a type: {}", + as a type: {:?}", a_def)[]); } } @@ -1626,7 +1626,7 @@ fn compute_opt_region_bound<'tcx>(tcx: &ty::ctxt<'tcx>, builtin_bounds: ty::BuiltinBounds) -> Option { - debug!("compute_opt_region_bound(explicit_region_bounds={}, \ + debug!("compute_opt_region_bound(explicit_region_bounds={:?}, \ principal_trait_ref={}, builtin_bounds={})", explicit_region_bounds, principal_trait_ref.repr(tcx), diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index 9945e264bfc2a..0079115756993 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -82,7 +82,7 @@ fn check_unboxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, expected_sig: Option>) { let expr_def_id = ast_util::local_def(expr.id); - debug!("check_unboxed_closure kind={} expected_sig={}", + debug!("check_unboxed_closure kind={:?} expected_sig={}", kind, expected_sig.repr(fcx.tcx())); @@ -134,7 +134,7 @@ fn check_unboxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, // the `unboxed_closures` table. fn_ty.sig.0.inputs = vec![ty::mk_tup(fcx.tcx(), fn_ty.sig.0.inputs)]; - debug!("unboxed_closure for {} --> sig={} kind={}", + debug!("unboxed_closure for {} --> sig={} kind={:?}", expr_def_id.repr(fcx.tcx()), fn_ty.sig.repr(fcx.tcx()), kind); @@ -186,7 +186,7 @@ fn deduce_unboxed_closure_expectations_from_trait_ref<'a,'tcx>( None => { return None; } }; - debug!("found object type {}", kind); + debug!("found object type {:?}", kind); let arg_param_ty = *trait_ref.substs().types.get(subst::TypeSpace, 0); let arg_param_ty = fcx.infcx().resolve_type_vars_if_possible(&arg_param_ty); diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index adea5084aab2b..dedfb316d3abc 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -200,7 +200,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { match pick.kind { probe::InherentImplPick(impl_def_id) => { assert!(ty::impl_trait_ref(self.tcx(), impl_def_id).is_none(), - "impl {} is not an inherent impl", impl_def_id); + "impl {:?} is not an inherent impl", impl_def_id); let impl_polytype = check::impl_self_ty(self.fcx, self.span, impl_def_id); (impl_polytype.substs, MethodStatic(pick.method_ty.def_id)) diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index ad43dd84ef6b2..8d925480ef942 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -231,7 +231,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, Some(self_expr) => { debug!("lookup_in_trait_adjusted: inserting adjustment if needed \ - (self-id={}, base adjustment={}, explicit_self={})", + (self-id={}, base adjustment={:?}, explicit_self={:?})", self_expr.id, autoderefref, method_ty.explicit_self); match method_ty.explicit_self { @@ -275,7 +275,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, fcx.tcx().sess.span_bug( span, format!( - "unexpected explicit self type in operator method: {}", + "unexpected explicit self type in operator method: {:?}", method_ty.explicit_self)[]); } } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 115711ae92b29..1859476218654 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -267,7 +267,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { return; // already visited } - debug!("assemble_inherent_impl_probe {}", impl_def_id); + debug!("assemble_inherent_impl_probe {:?}", impl_def_id); let method = match impl_method(self.tcx(), impl_def_id, self.method_name) { Some(m) => m, @@ -1024,7 +1024,7 @@ fn trait_method<'tcx>(tcx: &ty::ctxt<'tcx>, -> Option<(uint, Rc>)> { let trait_items = ty::trait_items(tcx, trait_def_id); - debug!("trait_method; items: {}", trait_items); + debug!("trait_method; items: {:?}", trait_items); trait_items .iter() .filter(|item| @@ -1126,7 +1126,7 @@ impl<'tcx> Repr<'tcx> for CandidateKind<'tcx> { impl<'tcx> Repr<'tcx> for CandidateStep<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { - format!("CandidateStep({},{})", + format!("CandidateStep({},{:?})", self.self_ty.repr(tcx), self.adjustment) } @@ -1134,19 +1134,19 @@ impl<'tcx> Repr<'tcx> for CandidateStep<'tcx> { impl<'tcx> Repr<'tcx> for PickAdjustment { fn repr(&self, _tcx: &ty::ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for PickKind<'tcx> { fn repr(&self, _tcx: &ty::ctxt) -> String { - format!("{}", self) + format!("{:?}", self) } } impl<'tcx> Repr<'tcx> for Pick<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { - format!("Pick(method_ty={}, adjustment={}, kind={})", + format!("Pick(method_ty={}, adjustment={:?}, kind={:?})", self.method_ty.repr(tcx), self.adjustment, self.kind) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1b51434a58cc1..049206a5157bd 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1690,7 +1690,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } pub fn tag(&self) -> String { - format!("{}", self as *const FnCtxt) + format!("{:?}", self as *const FnCtxt) } pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> { @@ -1886,7 +1886,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn register_unsize_obligations(&self, span: Span, unsize: &ty::UnsizeKind<'tcx>) { - debug!("register_unsize_obligations: unsize={}", unsize); + debug!("register_unsize_obligations: unsize={:?}", unsize); match *unsize { ty::UnsizeLength(..) => {} @@ -2474,7 +2474,7 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, lvalue_pref: LvaluePreference) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> { - debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={})", + debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={:?})", expr.repr(fcx.tcx()), base_expr.repr(fcx.tcx()), adjusted_ty.repr(fcx.tcx()), @@ -2731,7 +2731,7 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, err_args(fcx.tcx(), supplied_arg_count) }; - debug!("check_argument_types: formal_tys={}", + debug!("check_argument_types: formal_tys={:?}", formal_tys.iter().map(|t| fcx.infcx().ty_to_string(*t)).collect::>()); // Check the arguments. @@ -3181,7 +3181,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } }; - debug!("adjusted_ty={} adjustment={}", + debug!("adjusted_ty={} adjustment={:?}", adj_ty.repr(fcx.tcx()), adjustment); @@ -5178,7 +5178,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, } assert_eq!(segment_spaces.len(), path.segments.len()); - debug!("segment_spaces={}", segment_spaces); + debug!("segment_spaces={:?}", segment_spaces); // Next, examine the definition, and determine how many type // parameters we expect from each space. @@ -5402,7 +5402,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, .take_while(|d| d.default.is_none()) .count(); - debug!("adjust_type_parameters(space={}, \ + debug!("adjust_type_parameters(space={:?}, \ provided_len={}, \ desired_len={}, \ required_len={})", diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index c7df5ed8453fd..c81f0e65453d9 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -188,7 +188,7 @@ fn region_of_def(fcx: &FnCtxt, def: def::Def) -> ty::Region { } } _ => { - tcx.sess.bug(format!("unexpected def in region_of_def: {}", + tcx.sess.bug(format!("unexpected def in region_of_def: {:?}", def)[]) } } @@ -484,7 +484,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { // Check any autoderefs or autorefs that appear. for &adjustment in rcx.fcx.inh.adjustments.borrow().get(&expr.id).iter() { - debug!("adjustment={}", adjustment); + debug!("adjustment={:?}", adjustment); match *adjustment { ty::AdjustDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => { let expr_ty = rcx.resolve_node_type(expr.id); @@ -828,7 +828,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, debug!("constrain_free_variables({}, {})", region_bound.repr(tcx), expr.repr(tcx)); for freevar in freevars.iter() { - debug!("freevar def is {}", freevar.def); + debug!("freevar def is {:?}", freevar.def); // Identify the variable being closed over and its node-id. let def = freevar.def; @@ -1038,7 +1038,7 @@ fn type_of_node_must_outlive<'a, 'tcx>( rcx.fcx.inh.adjustments.borrow().get(&id), |method_call| rcx.resolve_method_type(method_call)); debug!("constrain_regions_in_type_of_node(\ - ty={}, ty0={}, id={}, minimum_lifetime={})", + ty={}, ty0={}, id={}, minimum_lifetime={:?})", ty_to_string(tcx, ty), ty_to_string(tcx, ty0), id, minimum_lifetime); type_must_outlive(rcx, origin, ty, minimum_lifetime); @@ -1090,7 +1090,7 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { /// then ensures that the lifetime of the resulting pointer is /// linked to the lifetime of its guarantor (if any). fn link_fn_args(rcx: &Rcx, body_scope: CodeExtent, args: &[ast::Arg]) { - debug!("regionck::link_fn_args(body_scope={})", body_scope); + debug!("regionck::link_fn_args(body_scope={:?})", body_scope); let mc = mc::MemCategorizationContext::new(rcx.fcx); for arg in args.iter() { let arg_ty = rcx.fcx.node_ty(arg.id); @@ -1144,7 +1144,7 @@ fn link_autoref(rcx: &Rcx, autoderefs: uint, autoref: &ty::AutoRef) { - debug!("link_autoref(autoref={})", autoref); + debug!("link_autoref(autoref={:?})", autoref); let mc = mc::MemCategorizationContext::new(rcx.fcx); let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs)); debug!("expr_cmt={}", expr_cmt.repr(rcx.tcx())); @@ -1165,7 +1165,7 @@ fn link_by_ref(rcx: &Rcx, expr: &ast::Expr, callee_scope: CodeExtent) { let tcx = rcx.tcx(); - debug!("link_by_ref(expr={}, callee_scope={})", + debug!("link_by_ref(expr={}, callee_scope={:?})", expr.repr(tcx), callee_scope); let mc = mc::MemCategorizationContext::new(rcx.fcx); let expr_cmt = ignore_err!(mc.cat_expr(expr)); diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 92fda96595c7b..ec44d765a8e68 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -134,7 +134,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { let var_node_id = freevar.def.local_node_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, closure_expr_id: expr.id }; - debug!("seed upvar_id {}", upvar_id); + debug!("seed upvar_id {:?}", upvar_id); let origin = UpvarRegion(upvar_id, expr.span); let freevar_region = self.infcx().next_region_var(origin); let upvar_borrow = ty::UpvarBorrow { kind: ty::ImmBorrow, @@ -269,7 +269,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx>{ upvar_id: ty::UpvarId, upvar_borrow: &mut ty::UpvarBorrow, kind: ty::BorrowKind) { - debug!("adjust_upvar_borrow_kind: id={} kind=({} -> {})", + debug!("adjust_upvar_borrow_kind: id={:?} kind=({:?} -> {:?})", upvar_id, upvar_borrow.kind, kind); match (upvar_borrow.kind, kind) { @@ -337,7 +337,7 @@ impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> { bk: ty::BorrowKind, _loan_cause: euv::LoanCause) { - debug!("borrow(borrow_id={}, cmt={}, bk={})", + debug!("borrow(borrow_id={}, cmt={}, bk={:?})", borrow_id, cmt.repr(self.tcx()), bk); match bk { diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 70644b6e7de5d..82da22eab9837 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -287,7 +287,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { }) } }; - debug!("Adjustments for node {}: {}", id, resolved_adjustment); + debug!("Adjustments for node {}: {:?}", id, resolved_adjustment); self.tcx().adjustments.borrow_mut().insert( id, resolved_adjustment); } @@ -300,7 +300,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { // Resolve any method map entry match self.fcx.inh.method_map.borrow_mut().remove(&method_call) { Some(method) => { - debug!("writeback::resolve_method_map_entry(call={}, entry={})", + debug!("writeback::resolve_method_map_entry(call={:?}, entry={})", method_call, method.repr(self.tcx())); let new_method = MethodCallee { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 09ab98745bd6a..210b3a803216f 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -204,7 +204,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { trait_ref: &ty::TraitRef<'tcx>, all_impl_items: &mut Vec) { let tcx = self.crate_context.tcx; - debug!("instantiate_default_methods(impl_id={}, trait_ref={})", + debug!("instantiate_default_methods(impl_id={:?}, trait_ref={})", impl_id, trait_ref.repr(tcx)); let impl_type_scheme = ty::lookup_item_type(tcx, impl_id); @@ -215,7 +215,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let new_id = tcx.sess.next_node_id(); let new_did = local_def(new_id); - debug!("new_did={} trait_method={}", new_did, trait_method.repr(tcx)); + debug!("new_did={:?} trait_method={}", new_did, trait_method.repr(tcx)); // Create substitutions for the various trait parameters. let new_method_ty = @@ -268,7 +268,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } fn add_trait_impl(&self, base_def_id: DefId, impl_def_id: DefId) { - debug!("add_trait_impl: base_def_id={} impl_def_id={}", + debug!("add_trait_impl: base_def_id={:?} impl_def_id={:?}", base_def_id, impl_def_id); ty::record_trait_implementation(self.crate_context.tcx, base_def_id, diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index bbafcdae1bba1..fe4d1dff052f1 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -169,8 +169,8 @@ impl<'a, 'tcx> AstConv<'tcx> for CollectCtxt<'a, 'tcx> { } x => { self.tcx.sess.bug(format!("unexpected sort of node \ - in get_item_type_scheme(): {}", - x).as_slice()); + in get_item_type_scheme(): {:?}", + x)[]); } } } @@ -475,7 +475,7 @@ fn convert_methods<'a,'tcx,'i,I>(ccx: &CollectCtxt<'a, 'tcx>, write_ty_to_tcx(tcx, m.id, fty); - debug!("writing method type: def_id={} mty={}", + debug!("writing method type: def_id={:?} mty={}", mty.def_id, mty.repr(ccx.tcx)); tcx.impl_or_trait_items @@ -840,7 +840,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ref s => { tcx.sess.span_bug( it.span, - format!("trait_def_of_item invoked on {}", s)[]); + format!("trait_def_of_item invoked on {:?}", s)[]); } }; @@ -1201,7 +1201,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, index: i as u32, def_id: local_def(l.lifetime.id), bounds: bounds }; - debug!("ty_generics: def for region param: {}", def); + debug!("ty_generics: def for region param: {:?}", def); result.regions.push(space, def); } @@ -1213,7 +1213,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, space, param, i as u32); - debug!("ty_generics: def for type param: {}, {}", + debug!("ty_generics: def for type param: {}, {:?}", def.repr(ccx.tcx), space); result.types.push(space, def); diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index e58c2275fcd96..70ebd96d91e89 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -243,8 +243,8 @@ enum VarianceTerm<'a> { impl<'a> fmt::Show for VarianceTerm<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - ConstantTerm(c1) => write!(f, "{}", c1), - TransformTerm(v1, v2) => write!(f, "({} \u{00D7} {})", v1, v2), + ConstantTerm(c1) => write!(f, "{:?}", c1), + TransformTerm(v1, v2) => write!(f, "({:?} \u{00D7} {:?})", v1, v2), InferredTerm(id) => write!(f, "[{}]", { let InferredIndex(i) = id; i }) } } @@ -323,10 +323,10 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { assert!(newly_added); debug!("add_inferred(item_id={}, \ - kind={}, \ + kind={:?}, \ index={}, \ param_id={}, - inf_index={})", + inf_index={:?})", item_id, kind, index, param_id, inf_index); } @@ -673,8 +673,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { fn add_constraint(&mut self, InferredIndex(index): InferredIndex, variance: VarianceTermPtr<'a>) { - debug!("add_constraint(index={}, variance={})", - index, variance.to_string()); + debug!("add_constraint(index={}, variance={:?})", + index, variance); self.constraints.push(Constraint { inferred: InferredIndex(index), variance: variance }); } @@ -854,7 +854,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { region_param_defs: &[ty::RegionParameterDef], substs: &subst::Substs<'tcx>, variance: VarianceTermPtr<'a>) { - debug!("add_constraints_from_substs(def_id={})", def_id); + debug!("add_constraints_from_substs(def_id={:?})", def_id); for p in type_param_defs.iter() { let variance_decl = @@ -988,14 +988,14 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { let new_value = glb(variance, old_value); if old_value != new_value { debug!("Updating inferred {} (node {}) \ - from {} to {} due to {}", + from {:?} to {:?} due to {:?}", inferred, self.terms_cx .inferred_infos[inferred] .param_id, old_value, new_value, - term.to_string()); + term); self.solutions[inferred] = new_value; changed = true; @@ -1028,7 +1028,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { inferred_infos[index].item_id == item_id { let info = &inferred_infos[index]; let variance = solutions[index]; - debug!("Index {} Info {} / {} / {} Variance {}", + debug!("Index {} Info {} / {:?} / {:?} Variance {:?}", index, info.index, info.kind, info.space, variance); match info.kind { TypeParam => { diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 3eda39f54a997..3e2474468adb6 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -397,9 +397,9 @@ fn build_const(cx: &DocContext, tcx: &ty::ctxt, use syntax::print::pprust; let expr = const_eval::lookup_const_by_id(tcx, did).unwrap_or_else(|| { - panic!("expected lookup_const_by_id to succeed for {}", did); + panic!("expected lookup_const_by_id to succeed for {:?}", did); }); - debug!("converting constant expr {} to snippet", expr); + debug!("converting constant expr {:?} to snippet", expr); let sn = pprust::expr_to_string(expr); debug!("got snippet {}", sn); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bb9a9ac430340..2f2b04b066694 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -397,7 +397,7 @@ impl Clean for doctree::Module { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum Attribute { Word(String), List(String, Vec ), @@ -450,7 +450,7 @@ impl<'a> attr::AttrMetaMethods for &'a Attribute { fn meta_item_list(&self) -> Option<&[P]> { None } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct TyParam { pub name: String, pub did: ast::DefId, @@ -483,7 +483,7 @@ impl<'tcx> Clean for ty::TypeParameterDef<'tcx> { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum TyParamBound { RegionBound(Lifetime), TraitBound(PolyTrait, ast::TraitBoundModifier) @@ -621,7 +621,7 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { cx.external_paths.borrow_mut().as_mut().unwrap().insert(self.def_id, (fqn, TypeTrait)); - debug!("ty::TraitRef\n substs.types(TypeSpace): {}\n", + debug!("ty::TraitRef\n substs.types(TypeSpace): {:?}\n", self.substs.types.get_slice(ParamSpace::TypeSpace)); // collect any late bound regions @@ -632,7 +632,7 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { for &ty_s in ts.iter() { if let sty::ty_rptr(ref reg, _) = ty_s.sty { if let &Region::ReLateBound(_, _) = *reg { - debug!(" hit an ReLateBound {}", reg); + debug!(" hit an ReLateBound {:?}", reg); if let Some(lt) = reg.clean(cx) { late_bounds.push(lt) } @@ -674,7 +674,7 @@ impl<'tcx> Clean>> for subst::Substs<'tcx> { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct Lifetime(String); impl Lifetime { @@ -724,7 +724,7 @@ impl Clean> for ty::Region { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum WherePredicate { BoundPredicate { ty: Type, bounds: Vec }, RegionPredicate { lifetime: Lifetime, bounds: Vec}, @@ -757,7 +757,7 @@ impl Clean for ast::WherePredicate { } // maybe use a Generic enum and use ~[Generic]? -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct Generics { pub lifetimes: Vec, pub type_params: Vec, @@ -908,7 +908,7 @@ impl Clean for doctree::Function { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct ClosureDecl { pub lifetimes: Vec, pub decl: FnDecl, @@ -929,14 +929,14 @@ impl Clean for ast::ClosureTy { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct FnDecl { pub inputs: Arguments, pub output: FunctionRetTy, pub attrs: Vec, } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct Arguments { pub values: Vec, } @@ -989,7 +989,7 @@ impl<'a, 'tcx> Clean for (ast::DefId, &'a ty::PolyFnSig<'tcx>) { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct Argument { pub type_: Type, pub name: String, @@ -1006,7 +1006,7 @@ impl Clean for ast::Arg { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum FunctionRetTy { Return(Type), NoReturn @@ -1181,7 +1181,7 @@ impl<'tcx> Clean for ty::ImplOrTraitItem<'tcx> { } /// A trait reference, which may have higher ranked lifetimes. -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct PolyTrait { pub trait_: Type, pub lifetimes: Vec @@ -1190,7 +1190,7 @@ pub struct PolyTrait { /// A representation of a Type suitable for hyperlinking purposes. Ideally one can get the original /// type out of the AST/ty::ctxt given one of these, if more information is needed. Most importantly /// it does not preserve mutability or boxes. -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum Type { /// structs/enums/traits (anything that'd be an ast::TyPath) ResolvedPath { @@ -1236,7 +1236,7 @@ pub enum Type { PolyTraitRef(Vec), } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy, Show)] pub enum PrimitiveType { Int, I8, I16, I32, I64, Uint, U8, U16, U32, U64, @@ -1376,7 +1376,7 @@ impl Clean for ast::Ty { Infer }, TyTypeof(..) => { - panic!("Unimplemented type {}", self.node) + panic!("Unimplemented type {:?}", self.node) }, } } @@ -1746,7 +1746,7 @@ impl Clean for syntax::codemap::Span { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct Path { pub global: bool, pub segments: Vec, @@ -1761,7 +1761,7 @@ impl Clean for ast::Path { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub enum PathParameters { AngleBracketed { lifetimes: Vec, @@ -1793,7 +1793,7 @@ impl Clean for ast::PathParameters { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct PathSegment { pub name: String, pub params: PathParameters @@ -1857,7 +1857,7 @@ impl Clean for doctree::Typedef { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)] pub struct BareFunctionDecl { pub unsafety: ast::Unsafety, pub generics: Generics, @@ -1892,7 +1892,7 @@ pub struct Static { impl Clean for doctree::Static { fn clean(&self, cx: &DocContext) -> Item { - debug!("claning static {}: {}", self.name.clean(cx), self); + debug!("cleaning static {}: {:?}", self.name.clean(cx), self); Item { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), @@ -2170,7 +2170,7 @@ trait ToSource { impl ToSource for syntax::codemap::Span { fn to_src(&self, cx: &DocContext) -> String { - debug!("converting span {} to snippet", self.clean(cx)); + debug!("converting span {:?} to snippet", self.clean(cx)); let sn = match cx.sess().codemap().span_to_snippet(*self) { Some(x) => x.to_string(), None => "".to_string() @@ -2183,7 +2183,7 @@ impl ToSource for syntax::codemap::Span { fn lit_to_string(lit: &ast::Lit) -> String { match lit.node { ast::LitStr(ref st, _) => st.get().to_string(), - ast::LitBinary(ref data) => format!("{}", data), + ast::LitBinary(ref data) => format!("{:?}", data), ast::LitByte(b) => { let mut res = String::from_str("b'"); for c in (b as char).escape_default() { @@ -2202,7 +2202,7 @@ fn lit_to_string(lit: &ast::Lit) -> String { fn name_from_pat(p: &ast::Pat) -> String { use syntax::ast::*; - debug!("Trying to get a name from pattern: {}", p); + debug!("Trying to get a name from pattern: {:?}", p); match p.node { PatWild(PatWildSingle) => "_".to_string(), diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index a69437f7a669c..46c212a9f2dbc 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -136,7 +136,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec, externs: Externs, inlined: RefCell::new(Some(HashSet::new())), populated_crate_impls: RefCell::new(HashSet::new()), }; - debug!("crate: {}", ctxt.krate); + debug!("crate: {:?}", ctxt.krate); let analysis = CrateAnalysis { exported_items: exported_items, diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs index b4afb67170bbd..99cd467cdfccc 100644 --- a/src/librustdoc/html/escape.rs +++ b/src/librustdoc/html/escape.rs @@ -19,7 +19,15 @@ use std::fmt; /// string when passed to a format string. pub struct Escape<'a>(pub &'a str); +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Escape<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Escape<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { // Because the internet is always right, turns out there's not that many // characters to escape: http://stackoverflow.com/questions/7381974 diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 9004d11b5bccf..23a99ae36ea56 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -10,7 +10,7 @@ //! HTML formatting module //! -//! This module contains a large number of `fmt::Show` implementations for +//! This module contains a large number of `fmt::String` implementations for //! various types in `rustdoc::clean`. These implementations all currently //! assume that HTML output is desired, although it may be possible to redesign //! them in the future to instead emit any format desired. @@ -64,7 +64,15 @@ impl UnsafetySpace { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for TyParamBounds<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for TyParamBounds<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let &TyParamBounds(bounds) = self; for (i, bound) in bounds.iter().enumerate() { @@ -77,7 +85,15 @@ impl<'a> fmt::Show for TyParamBounds<'a> { } } -impl fmt::Show for clean::Generics { +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] +impl fmt::Show for clean::Generic { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::Generics { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) } try!(f.write_str("<")); @@ -114,7 +130,15 @@ impl fmt::Show for clean::Generics { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for WhereClause<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for WhereClause<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let &WhereClause(gens) = self; if gens.where_predicates.len() == 0 { @@ -151,14 +175,30 @@ impl<'a> fmt::Show for WhereClause<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::Lifetime { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::Lifetime { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(f.write_str(self.get_ref())); Ok(()) } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::PolyTrait { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::PolyTrait { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.lifetimes.len() > 0 { try!(f.write_str("for<")); @@ -174,7 +214,15 @@ impl fmt::Show for clean::PolyTrait { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::TyParamBound { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::TyParamBound { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::RegionBound(ref lt) => { @@ -191,7 +239,15 @@ impl fmt::Show for clean::TyParamBound { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::PathParameters { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::PathParameters { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => { @@ -236,14 +292,30 @@ impl fmt::Show for clean::PathParameters { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::PathSegment { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::PathSegment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(f.write_str(self.name.as_slice())); write!(f, "{}", self.params) } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::Path { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::Path { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.global { try!(f.write_str("::")) @@ -429,7 +501,15 @@ fn tybounds(w: &mut fmt::Formatter, } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::Type { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::Type { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::TyParamBinder(id) => { @@ -570,7 +650,16 @@ impl fmt::Show for clean::Type { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::Arguments { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + + +impl fmt::String for clean::Arguments { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (i, input) in self.values.iter().enumerate() { if i > 0 { try!(write!(f, ", ")); } @@ -583,7 +672,15 @@ impl fmt::Show for clean::Arguments { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::FunctionRetTy { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::FunctionRetTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::Return(clean::Tuple(ref tys)) if tys.is_empty() => Ok(()), @@ -593,13 +690,29 @@ impl fmt::Show for clean::FunctionRetTy { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::FnDecl { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::FnDecl { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output) } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Method<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Method<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Method(selfty, d) = *self; let mut args = String::new(); @@ -629,7 +742,15 @@ impl<'a> fmt::Show for Method<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for VisSpace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for VisSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.get() { Some(ast::Public) => write!(f, "pub "), @@ -638,7 +759,15 @@ impl fmt::Show for VisSpace { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for UnsafetySpace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for UnsafetySpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.get() { ast::Unsafety::Unsafe => write!(f, "unsafe "), @@ -647,7 +776,15 @@ impl fmt::Show for UnsafetySpace { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::ViewPath { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::ViewPath { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { clean::SimpleImport(ref name, ref src) => { @@ -674,7 +811,15 @@ impl fmt::Show for clean::ViewPath { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::ImportSource { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::ImportSource { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.did { Some(did) => resolved_path(f, did, &self.path, true), @@ -691,7 +836,15 @@ impl fmt::Show for clean::ImportSource { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for clean::ViewListIdent { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for clean::ViewListIdent { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.source { Some(did) => { @@ -712,7 +865,15 @@ impl fmt::Show for clean::ViewListIdent { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for MutableSpace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for MutableSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { MutableSpace(clean::Immutable) => Ok(()), @@ -721,7 +882,15 @@ impl fmt::Show for MutableSpace { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for RawMutableSpace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for RawMutableSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { RawMutableSpace(clean::Immutable) => write!(f, "const "), @@ -730,13 +899,21 @@ impl fmt::Show for RawMutableSpace { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Stability<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Stability<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Stability(stab) = *self; match *stab { Some(ref stability) => { write!(f, "{lvl}", - lvl = stability.level.to_string(), + lvl = stability.level, reason = stability.text) } None => Ok(()) @@ -744,13 +921,21 @@ impl<'a> fmt::Show for Stability<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for ConciseStability<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for ConciseStability<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let ConciseStability(stab) = *self; match *stab { Some(ref stability) => { write!(f, "", - lvl = stability.level.to_string(), + lvl = stability.level, colon = if stability.text.len() > 0 { ": " } else { "" }, reason = stability.text) } @@ -761,7 +946,15 @@ impl<'a> fmt::Show for ConciseStability<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for ModuleSummary { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for ModuleSummary { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt_inner<'a>(f: &mut fmt::Formatter, context: &mut Vec<&'a str>, diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index 3efaf5d491442..13a06f842a276 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -103,7 +103,15 @@ impl ItemType { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl fmt::Show for ItemType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl fmt::String for ItemType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.to_static_str().fmt(f) } diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs index d47c6010be0ba..f75ab3f431c2a 100644 --- a/src/librustdoc/html/layout.rs +++ b/src/librustdoc/html/layout.rs @@ -30,7 +30,7 @@ pub struct Page<'a> { pub keywords: &'a str } -pub fn render( +pub fn render( dst: &mut io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T) -> io::IoResult<()> { diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 3b9265cf56976..f4660a81be496 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -14,7 +14,7 @@ //! (bundled into the rust runtime). This module self-contains the C bindings //! and necessary legwork to render markdown, and exposes all of the //! functionality through a unit-struct, `Markdown`, which has an implementation -//! of `fmt::Show`. Example usage: +//! of `fmt::String`. Example usage: //! //! ```rust,ignore //! use rustdoc::html::markdown::Markdown; @@ -41,7 +41,7 @@ use html::highlight; use html::escape::Escape; use test; -/// A unit struct which has the `fmt::Show` trait implemented. When +/// A unit struct which has the `fmt::String` trait implemented. When /// formatted, this struct will emit the HTML corresponding to the rendered /// version of the contained markdown string. pub struct Markdown<'a>(pub &'a str); @@ -172,7 +172,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let text = slice::from_raw_buf(&(*orig_text).data, (*orig_text).size as uint); let origtext = str::from_utf8(text).unwrap(); - debug!("docblock: ==============\n{}\n=======", text); + debug!("docblock: ==============\n{:?}\n=======", text); let rendered = if lang.is_null() { false } else { @@ -435,7 +435,15 @@ pub fn reset_headers() { TEST_IDX.with(|s| s.set(0)); } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Markdown<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Markdown<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let Markdown(md) = *self; // This is actually common enough to special-case @@ -444,7 +452,15 @@ impl<'a> fmt::Show for Markdown<'a> { } } +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for MarkdownWithToc<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for MarkdownWithToc<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let MarkdownWithToc(md) = *self; render(fmt, md.as_slice(), true) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index ddb14d6944b9d..5ec970c5a50ff 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1051,7 +1051,7 @@ impl Context { F: FnOnce(&mut Context) -> T, { if s.len() == 0 { - panic!("Unexpected empty destination: {}", self.current); + panic!("Unexpected empty destination: {:?}", self.current); } let prev = self.dst.clone(); self.dst.push(s.as_slice()); @@ -1351,8 +1351,15 @@ impl<'a> Item<'a> { } - +//NOTE(stage0): remove impl after snapshot +#[cfg(stage0)] impl<'a> fmt::Show for Item<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::String::fmt(self, f) + } +} + +impl<'a> fmt::String for Item<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { // Write the breadcrumb trail header for the top try!(write!(fmt, "\n