user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rollup merge of #22502: nikomatsakis/deprecate-bracket-bracket

Browse source 
Conflicts:
	src/libcollections/slice.rs
	src/libcollections/str.rs
	src/librustc/middle/lang_items.rs
	src/librustc_back/rpath.rs
	src/librustc_typeck/check/regionck.rs
	src/libstd/ffi/os_str.rs
	src/libsyntax/diagnostic.rs
	src/libsyntax/parse/parser.rs
	src/libsyntax/util/interner.rs
	src/test/run-pass/regions-refcell.rs
This commit is contained in:
Alex Crichton 2015-02-18 15:48:40 -08:00
commit 231eeaa35b
146 changed files with 895 additions and 882 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libsyntax/ext/concat.rs
View file

@ -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[..])))
}

2
src/libsyntax/ext/concat_idents.rs
View file

@ -49,7 +49,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[..]);
let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID,

2
src/libsyntax/ext/deriving/bounds.rs
View file

@ -24,7 +24,7 @@ pub fn expand_deriving_bound<F>(cx: &mut ExtCtxt,
{
let name = match mitem.node {
MetaWord(ref tname) => {
match &tname[] {
match &tname[..] {
"Copy" => "Copy",
"Send" | "Sync" => {
return cx.span_err(span,

32
src/libsyntax/ext/deriving/generic/mod.rs
View file

@ -536,15 +536,15 @@ impl<'a> TraitDef<'a> {
self,
struct_def,
type_ident,
&self_args[],
&nonself_args[])
&self_args[..],
&nonself_args[..])
} else {
method_def.expand_struct_method_body(cx,
self,
struct_def,
type_ident,
&self_args[],
&nonself_args[])
&self_args[..],
&nonself_args[..])
};
method_def.create_method(cx,
@ -576,15 +576,15 @@ impl<'a> TraitDef<'a> {
self,
enum_def,
type_ident,
&self_args[],
&nonself_args[])
&self_args[..],
&nonself_args[..])
} else {
method_def.expand_enum_method_body(cx,
self,
enum_def,
type_ident,
self_args,
&nonself_args[])
&nonself_args[..])
};
method_def.create_method(cx,
@ -934,22 +934,22 @@ impl<'a> MethodDef<'a> {
.collect::<Vec<String>>();
let self_arg_idents = self_arg_names.iter()
.map(|name|cx.ident_of(&name[]))
.map(|name|cx.ident_of(&name[..]))
.collect::<Vec<ast::Ident>>();
// The `vi_idents` will be bound, solely in the catch-all, to
// a series of let statements mapping each self_arg to a usize
// corresponding to its variant index.
let vi_idents: Vec<ast::Ident> = 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[..]);
cx.ident_of(&vi_suffix[..]) })
.collect::<Vec<ast::Ident>>();
// 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[..], &vi_idents[..]);
// These arms are of the form:
// (Variant1, Variant1, ...) => Body1
@ -976,7 +976,7 @@ impl<'a> MethodDef<'a> {
idents
};
for self_arg_name in self_arg_names.tail() {
let (p, idents) = mk_self_pat(cx, &self_arg_name[]);
let (p, idents) = mk_self_pat(cx, &self_arg_name[..]);
subpats.push(p);
self_pats_idents.push(idents);
}
@ -1032,7 +1032,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[..], nonself_args,
&substructure);
cx.arm(sp, vec![single_pat], arm_expr)
@ -1085,7 +1085,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[..], nonself_args,
&catch_all_substructure);
// Builds the expression:
@ -1391,7 +1391,7 @@ pub fn cs_fold<F>(use_foldl: bool,
}
},
EnumNonMatchingCollapsed(ref all_args, _, tuple) =>
enum_nonmatch_f(cx, trait_span, (&all_args[], tuple),
enum_nonmatch_f(cx, trait_span, (&all_args[..], tuple),
substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `derive`")
@ -1431,7 +1431,7 @@ pub fn cs_same_method<F>(f: F,
f(cx, trait_span, called)
},
EnumNonMatchingCollapsed(ref all_self_args, _, tuple) =>
enum_nonmatch_f(cx, trait_span, (&all_self_args[], tuple),
enum_nonmatch_f(cx, trait_span, (&all_self_args[..], tuple),
substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `derive`")

2
src/libsyntax/ext/deriving/mod.rs
View file

@ -102,7 +102,7 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt,
|i| push(i)))
}
match &tname[] {
match &tname[..] {
"Clone" => expand!(clone::expand_deriving_clone),
"Hash" => expand!(hash::expand_deriving_hash),

2
src/libsyntax/ext/deriving/show.rs
View file

@ -128,7 +128,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[..]);
let format_string = cx.expr_str(span, s);
// phew, not our responsibility any more!

6
src/libsyntax/ext/env.rs
View file

@ -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 env::var(&var[]) {
let e = match env::var(&var[..]) {
Err(..) => {
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[..]))))
}
};
MacExpr::new(e)
@ -101,7 +101,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
}
}
let e = match env::var(&var[]) {
let e = match env::var(&var[..]) {
Err(_) => {
cx.span_err(sp, &msg);
cx.expr_usize(sp, 0)

26
src/libsyntax/ext/expand.rs
View file

@ -405,7 +405,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
},
});
let fm = fresh_mark();
let marked_before = mark_tts(&tts[], fm);
let marked_before = mark_tts(&tts[..], fm);
// The span that we pass to the expanders we want to
// be the root of the call stack. That's the most
@ -416,7 +416,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
let opt_parsed = {
let expanded = expandfun.expand(fld.cx,
mac_span,
&marked_before[]);
&marked_before[..]);
parse_thunk(expanded)
};
let parsed = match opt_parsed {
@ -425,7 +425,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
fld.cx.span_err(
pth.span,
&format!("non-expression macro in expression position: {}",
&extnamestr[]
&extnamestr[..]
)[]);
return None;
}
@ -633,8 +633,8 @@ pub fn expand_item_mac(it: P<ast::Item>,
}
});
// mark before expansion:
let marked_before = mark_tts(&tts[], fm);
expander.expand(fld.cx, it.span, &marked_before[])
let marked_before = mark_tts(&tts[..], fm);
expander.expand(fld.cx, it.span, &marked_before[..])
}
IdentTT(ref expander, span) => {
if it.ident.name == parse::token::special_idents::invalid.name {
@ -652,7 +652,7 @@ pub fn expand_item_mac(it: P<ast::Item>,
}
});
// mark before expansion:
let marked_tts = mark_tts(&tts[], fm);
let marked_tts = mark_tts(&tts[..], fm);
expander.expand(fld.cx, it.span, it.ident, marked_tts)
}
MacroRulesTT => {
@ -971,11 +971,11 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
});
let fm = fresh_mark();
let marked_before = mark_tts(&tts[], fm);
let marked_before = mark_tts(&tts[..], fm);
let mac_span = fld.cx.original_span();
let expanded = match expander.expand(fld.cx,
mac_span,
&marked_before[]).make_pat() {
&marked_before[..]).make_pat() {
Some(e) => e,
None => {
fld.cx.span_err(
@ -1128,7 +1128,7 @@ fn expand_annotatable(a: Annotatable,
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[..]);
let result = with_exts_frame!(fld.cx.syntax_env,
macro_use,
noop_fold_item(it, fld));
@ -1508,7 +1508,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[..]),
mtwt::apply_mark(self.mark, ctxt))
}
},
@ -1914,7 +1914,7 @@ mod test {
.collect();
println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
let string = token::get_ident(final_varref_ident);
println!("varref's first segment's string: \"{}\"", &string[]);
println!("varref's first segment's string: \"{}\"", &string[..]);
println!("binding #{}: {}, resolves to {}",
binding_idx, bindings[binding_idx], binding_name);
mtwt::with_sctable(|x| mtwt::display_sctable(x));
@ -1967,10 +1967,10 @@ foo_module!();
let cxbinds: Vec<&ast::Ident> =
bindings.iter().filter(|b| {
let ident = token::get_ident(**b);
let string = &ident[];
let string = &ident[..];
"xx" == string
}).collect();
let cxbinds: &[&ast::Ident] = &cxbinds[];
let cxbinds: &[&ast::Ident] = &cxbinds[..];
let cxbind = match cxbinds {
[b] => b,
_ => panic!("expected just one binding for ext_cx")

8
src/libsyntax/ext/format.rs
View file

@ -118,7 +118,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
}
};
let interned_name = token::get_ident(ident);
let name = &interned_name[];
let name = &interned_name[..];
p.expect(&token::Eq);
let e = p.parse_expr();
@ -218,7 +218,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[..]);
return;
}
{
@ -238,7 +238,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[..]);
return;
}
};
@ -587,7 +587,7 @@ impl<'a, 'b> Context<'a, 'b> {
-> P<ast::Expr> {
let trait_ = match *ty {
Known(ref tyname) => {
match &tyname[] {
match &tyname[..] {
"" => "Display",
"?" => "Debug",
"e" => "LowerExp",

4
src/libsyntax/ext/quote.rs
View file

@ -668,7 +668,7 @@ fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> {
for i in 0..tt.len() {
seq.push(tt.get_tt(i));
}
mk_tts(cx, &seq[])
mk_tts(cx, &seq[..])
}
ast::TtToken(sp, ref tok) => {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
@ -757,7 +757,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[..]).into_iter());
let block = cx.expr_block(
cx.block_all(sp,
vector,

6
src/libsyntax/ext/source_util.rs
View file

@ -65,7 +65,7 @@ pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-> Box<base::MacResult+'static> {
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[..])))
}
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[..])))
}
/// include! : parse the given file as an expr
@ -151,7 +151,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 = format!("{}", file.display());
let interned = token::intern_and_get_ident(&src[]);
let interned = token::intern_and_get_ident(&src[..]);
cx.codemap().new_filemap(filename, src);
base::MacExpr::new(cx.expr_str(sp, interned))

12
src/libsyntax/ext/tt/macro_parser.rs
View file

@ -165,7 +165,7 @@ pub fn count_names(ms: &[TokenTree]) -> usize {
pub fn initial_matcher_pos(ms: Rc<Vec<TokenTree>>, sep: Option<Token>, lo: BytePos)
-> Box<MatcherPos> {
let match_idx_hi = count_names(&ms[]);
let match_idx_hi = count_names(&ms[..]);
let matches: Vec<_> = (0..match_idx_hi).map(|_| Vec::new()).collect();
box MatcherPos {
stack: vec![],
@ -254,13 +254,13 @@ pub fn parse_or_else(sess: &ParseSess,
rdr: TtReader,
ms: Vec<TokenTree> )
-> HashMap<Ident, Rc<NamedMatch>> {
match parse(sess, cfg, rdr, &ms[]) {
match parse(sess, cfg, rdr, &ms[..]) {
Success(m) => m,
Failure(sp, str) => {
sess.span_diagnostic.span_fatal(sp, &str[])
sess.span_diagnostic.span_fatal(sp, &str[..])
}
Error(sp, str) => {
sess.span_diagnostic.span_fatal(sp, &str[])
sess.span_diagnostic.span_fatal(sp, &str[..])
}
}
}
@ -447,7 +447,7 @@ pub fn parse(sess: &ParseSess,
for dv in &mut (&mut eof_eis[0]).matches {
v.push(dv.pop().unwrap());
}
return Success(nameize(sess, ms, &v[]));
return Success(nameize(sess, ms, &v[..]));
} else if eof_eis.len() > 1 {
return Error(sp, "ambiguity: multiple successful parses".to_string());
} else {
@ -533,7 +533,7 @@ pub fn parse_nt(p: &mut Parser, sp: Span, name: &str) -> Nonterminal {
_ => {
let token_str = pprust::token_to_string(&p.token);
p.fatal(&format!("expected ident, found {}",
&token_str[])[])
&token_str[..])[])
}
},
"path" => {

6
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -50,7 +50,7 @@ impl<'a> ParserAnyMacro<'a> {
following",
token_str);
let span = parser.span;
parser.span_err(span, &msg[]);
parser.span_err(span, &msg[..]);
}
}
}
@ -192,13 +192,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[..])
}
}
_ => 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[..]);
}
// Note that macro-by-example's input is also matched against a token tree:

2
src/libsyntax/ext/tt/transcribe.rs
View file

@ -255,7 +255,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[..]);
}
LisConstraint(len, _) => {
if len == 0 {