OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Round 3 test fixes and conflicts

Browse Source
This commit is contained in:
Alex Crichton 2015-02-18 15:58:07 -08:00
parent 1506b34e0c
commit d6e939a2df
28 changed files with 127 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libcore/array.rs
View File

@ -45,7 +45,7 @@ macro_rules! array_impls {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Hash> Hash for [T; $N] {
fn hash<H: hash::Hasher>(&self, state: &mut H) {
Hash::hash(&self[], state)
Hash::hash(&self[..], state)
}
}

9
src/libcore/hash/mod.rs
View File

@ -494,13 +494,4 @@ mod impls {
state.write_usize(*self as usize)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T, B: ?Sized> Hash for Cow<'a, T, B>
where B: Hash + ToOwned<T>
{
fn hash<H: Hasher>(&self, state: &mut H) {
Hash::hash(&**self, state)
}
}
}

7
src/libcore/marker.rs
View File

@ -233,11 +233,18 @@ pub struct Managed;
macro_rules! impls{
($t: ident) => (
#[cfg(stage0)]
impl<T:?Sized, S: Hasher> Hash<S> for $t<T> {
#[inline]
fn hash(&self, _: &mut S) {
}
}
#[cfg(not(stage0))]
impl<T:?Sized> Hash for $t<T> {
#[inline]
fn hash<H: Hasher>(&self, _: &mut H) {
}
}
impl<T:?Sized> cmp::PartialEq for $t<T> {
fn eq(&self, _other: &$t<T>) -> bool {

19
src/libgraphviz/lib.rs
View File

@ -275,15 +275,12 @@
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![feature(int_uint)]
#![feature(collections)]
#![feature(core)]
#![feature(old_io)]
use self::LabelText::*;
use std::borrow::IntoCow;
use std::borrow::{IntoCow, Cow};
use std::old_io;
use std::string::CowString;
use std::vec::CowVec;
/// The text for a graphviz label on a node or edge.
pub enum LabelText<'a> {
@ -291,7 +288,7 @@ pub enum LabelText<'a> {
///
/// Occurrences of backslashes (`\`) are escaped, and thus appear
/// as backslashes in the rendered label.
LabelStr(CowString<'a>),
LabelStr(Cow<'a, str>),
/// This kind of label uses the graphviz label escString type:
/// http://www.graphviz.org/content/attrs#kescString
@ -303,7 +300,7 @@ pub enum LabelText<'a> {
/// to break a line (centering the line preceding the `\n`), there
/// are also the escape sequences `\l` which left-justifies the
/// preceding line and `\r` which right-justifies it.
EscStr(CowString<'a>),
EscStr(Cow<'a, str>),
}
// There is a tension in the design of the labelling API.
@ -340,7 +337,7 @@ pub enum LabelText<'a> {
/// `Id` is a Graphviz `ID`.
pub struct Id<'a> {
name: CowString<'a>,
name: Cow<'a, str>,
}
impl<'a> Id<'a> {
@ -387,7 +384,7 @@ impl<'a> Id<'a> {
&*self.name
}
pub fn name(self) -> CowString<'a> {
pub fn name(self) -> Cow<'a, str> {
self.name
}
}
@ -463,7 +460,7 @@ impl<'a> LabelText<'a> {
/// yields same content as self. The result obeys the law
/// render(`lt`) == render(`EscStr(lt.pre_escaped_content())`) for
/// all `lt: LabelText`.
fn pre_escaped_content(self) -> CowString<'a> {
fn pre_escaped_content(self) -> Cow<'a, str> {
match self {
EscStr(s) => s,
LabelStr(s) => if s.contains_char('\\') {
@ -489,8 +486,8 @@ impl<'a> LabelText<'a> {
}
}
pub type Nodes<'a,N> = CowVec<'a,N>;
pub type Edges<'a,E> = CowVec<'a,E>;
pub type Nodes<'a,N> = Cow<'a,[N]>;
pub type Edges<'a,E> = Cow<'a,[E]>;
// (The type parameters in GraphWalk should be associated items,
// when/if Rust supports such.)

10
src/libsyntax/diagnostic.rs
View File

@ -311,16 +311,16 @@ fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level,
}
try!(print_maybe_styled(dst,
&format!("{}: ", lvl.to_string())[],
&format!("{}: ", lvl.to_string()),
term::attr::ForegroundColor(lvl.color())));
try!(print_maybe_styled(dst,
&format!("{}", msg)[],
&format!("{}", msg),
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()), style));
}
None => ()
}
@ -438,7 +438,7 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan,
Some(_) => {
try!(print_diagnostic(dst, &ss[..], Help,
&format!("pass `--explain {}` to see a detailed \
explanation", code)[], None));
explanation", code), None));
}
None => ()
},
@ -542,7 +542,7 @@ fn highlight_lines(err: &mut EmitterWriter,
}
try!(print_maybe_styled(err,
&format!("{}\n", s)[],
&format!("{}\n", s),
term::attr::ForegroundColor(lvl.color())));
}
}

8
src/libsyntax/ext/source_util.rs
View File

@ -117,7 +117,7 @@ pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree
None => self.p.span_fatal(
self.p.span,
&format!("expected item, found `{}`",
self.p.this_token_to_string())[]
self.p.this_token_to_string())
)
}
}
@ -141,7 +141,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));
return DummyResult::expr(sp);
}
Ok(bytes) => bytes,
@ -159,7 +159,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()));
return DummyResult::expr(sp);
}
}
@ -175,7 +175,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));
return DummyResult::expr(sp);
}
Ok(bytes) => {

6
src/libsyntax/ext/tt/macro_parser.rs
View File

@ -229,7 +229,7 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc<NamedMatch>])
p_s.span_diagnostic
.span_fatal(sp,
&format!("duplicated bind name: {}",
&string)[])
&string))
}
}
}
@ -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" => {
@ -542,7 +542,7 @@ pub fn parse_nt(p: &mut Parser, sp: Span, name: &str) -> Nonterminal {
"meta" => token::NtMeta(p.parse_meta_item()),
_ => {
p.span_fatal_help(sp,
&format!("invalid fragment specifier `{}`", name)[],
&format!("invalid fragment specifier `{}`", name),
"valid fragment specifiers are `ident`, `block`, \
`stmt`, `expr`, `pat`, `ty`, `path`, `meta`, `tt` \
and `item`")

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

@ -123,8 +123,8 @@ impl TTMacroExpander for MacroRulesMacroExpander {
self.name,
self.imported_from,
arg,
&self.lhses[],
&self.rhses[])
&self.lhses,
&self.rhses)
}
}
@ -151,7 +151,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[..],
_ => cx.span_fatal(sp, "malformed macro lhs")
};
// `None` is because we're not interpolating

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

@ -309,7 +309,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)));
}
}
}

5
src/libsyntax/parse/lexer/mod.rs
View File

@ -16,14 +16,13 @@ use ext::tt::transcribe::tt_next_token;
use parse::token;
use parse::token::{str_to_ident};
use std::borrow::IntoCow;
use std::borrow::{IntoCow, Cow};
use std::char;
use std::fmt;
use std::mem::replace;
use std::num;
use std::rc::Rc;
use std::str;
use std::string::CowString;
pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag};
@ -278,7 +277,7 @@ impl<'a> StringReader<'a> {
/// Converts CRLF to LF in the given string, raising an error on bare CR.
fn translate_crlf<'b>(&self, start: BytePos,
s: &'b str, errmsg: &'b str) -> CowString<'b> {
s: &'b str, errmsg: &'b str) -> Cow<'b, str> {
let mut i = 0;
while i < s.len() {
let str::CharRange { ch, next } = s.char_range_at(i);

46
src/libsyntax/parse/parser.rs
View File

@ -4401,7 +4401,7 @@ impl<'a> Parser<'a> {
_ => {
let token_str = self.this_token_to_string();
self.fatal(&format!("expected `Self`, found `{}`",
token_str)[])
token_str))
}
}
}
@ -4536,7 +4536,7 @@ impl<'a> Parser<'a> {
_ => {
let token_str = self.this_token_to_string();
self.fatal(&format!("expected `,` or `)`, found `{}`",
token_str)[])
token_str))
}
}
}
@ -4939,7 +4939,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())));
}
self.bump();
@ -4947,7 +4947,7 @@ impl<'a> Parser<'a> {
let token_str = self.this_token_to_string();
self.fatal(&format!("expected `where`, or `{}` after struct \
name, found `{}`", "{",
token_str)[]);
token_str));
}
fields
@ -4978,7 +4978,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())));
}
self.parse_where_clause(generics);
@ -4993,7 +4993,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));
}
}
@ -5013,7 +5013,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),
"struct fields should be separated by commas")
}
}
@ -5085,7 +5085,7 @@ impl<'a> Parser<'a> {
// Parse all of the items up to closing or an attribute.
let mut attrs = first_item_attrs;
attrs.push_all(&self.parse_outer_attributes()[]);
attrs.push_all(&self.parse_outer_attributes());
let mut items = vec![];
loop {
@ -5105,14 +5105,14 @@ impl<'a> Parser<'a> {
while self.token != term {
let mut attrs = mem::replace(&mut attrs, vec![]);
attrs.push_all(&self.parse_outer_attributes()[]);
attrs.push_all(&self.parse_outer_attributes());
debug!("parse_mod_items: parse_item_(attrs={:?})", attrs);
match self.parse_item_(attrs, true /* macros allowed */) {
Ok(item) => items.push(item),
Err(_) => {
let token_str = self.this_token_to_string();
self.fatal(&format!("expected item, found `{}`",
token_str)[])
token_str))
}
}
}
@ -5216,13 +5216,13 @@ impl<'a> Parser<'a> {
&format!("maybe move this module `{0}` \
to its own directory via \
`{0}/mod.rs`",
this_module)[]);
this_module));
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));
}
self.abort_if_errors();
}
@ -5233,12 +5233,12 @@ impl<'a> Parser<'a> {
(false, false) => {
self.span_fatal_help(id_sp,
&format!("file not found for module `{}`",
mod_name)[],
mod_name),
&format!("name the file either {} or {} inside \
the directory {:?}",
default_path_str,
secondary_path_str,
dir_path.display())[]);
dir_path.display()));
}
(true, true) => {
self.span_fatal_help(
@ -5247,7 +5247,7 @@ impl<'a> Parser<'a> {
and {}",
mod_name,
default_path_str,
secondary_path_str)[],
secondary_path_str),
"delete or rename one of them to remove the ambiguity");
}
}
@ -5269,10 +5269,10 @@ impl<'a> Parser<'a> {
let mut err = String::from_str("circular modules: ");
let len = included_mod_stack.len();
for p in &included_mod_stack[i.. len] {
err.push_str(&p.display().as_cow()[]);
err.push_str(&p.display().as_cow());
err.push_str(" -> ");
}
err.push_str(&path.display().as_cow()[]);
err.push_str(&path.display().as_cow());
self.span_fatal(id_sp, &err[..]);
}
None => ()
@ -5378,7 +5378,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()));
None
} else {
None
@ -5404,7 +5404,7 @@ impl<'a> Parser<'a> {
self.span_fatal(span,
&format!("expected extern crate name but \
found `{}`",
token_str)[]);
token_str));
}
};
@ -5502,7 +5502,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)));
}
kind = StructVariantKind(struct_def);
} else if self.check(&token::OpenDelim(token::Paren)) {
@ -5580,7 +5580,7 @@ impl<'a> Parser<'a> {
&format!("illegal ABI: expected one of [{}], \
found `{}`",
abi::all_names().connect(", "),
the_string)[]);
the_string));
None
}
}
@ -5660,7 +5660,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));
}
if self.eat_keyword_noexpect(keywords::Virtual) {
@ -6054,7 +6054,7 @@ impl<'a> Parser<'a> {
fn parse_foreign_items(&mut self, first_item_attrs: Vec<Attribute>)
-> Vec<P<ForeignItem>> {
let mut attrs = first_item_attrs;
attrs.push_all(&self.parse_outer_attributes()[]);
attrs.push_all(&self.parse_outer_attributes());
let mut foreign_items = Vec::new();
loop {
match self.parse_foreign_item(attrs) {

4
src/libsyntax/print/pp.rs
View File

@ -539,8 +539,8 @@ impl Printer {
pub fn print(&mut self, token: Token, l: isize) -> old_io::IoResult<()> {
debug!("print {} {} (remaining line space={})", tok_str(&token), l,
self.space);
debug!("{}", buf_str(&self.token[],
&self.size[],
debug!("{}", buf_str(&self.token,
&self.size,
self.left,
self.right,
6));

102
src/libsyntax/print/pprust.rs
View File

@ -134,7 +134,7 @@ pub fn print_crate<'a>(cm: &'a CodeMap,
try!(s.print_attribute(&fake_attr));
}
try!(s.print_mod(&krate.module, &krate.attrs[]));
try!(s.print_mod(&krate.module, &krate.attrs));
try!(s.print_remaining_comments());
eof(&mut s.s)
}
@ -765,7 +765,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));
match item.node {
ast::ForeignItemFn(ref decl, ref generics) => {
try!(self.print_fn(&**decl, None, abi::Rust, item.ident, generics,
@ -776,7 +776,7 @@ impl<'a> State<'a> {
}
ast::ForeignItemStatic(ref t, m) => {
try!(self.head(&visibility_qualified(item.vis,
"static")[]));
"static")));
if m {
try!(self.word_space("mut"));
}
@ -793,7 +793,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));
try!(self.word_space("type"));
try!(self.print_ty_param(&typedef.ty_param));
word(&mut self.s, ";")
@ -812,12 +812,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));
try!(self.ann.pre(self, NodeItem(item)));
match item.node {
ast::ItemExternCrate(ref optional_path) => {
try!(self.head(&visibility_qualified(item.vis,
"extern crate")[]));
"extern crate")));
if let Some((ref p, style)) = *optional_path {
try!(self.print_string(p, style));
try!(space(&mut self.s));
@ -831,7 +831,7 @@ impl<'a> State<'a> {
}
ast::ItemUse(ref vp) => {
try!(self.head(&visibility_qualified(item.vis,
"use")[]));
"use")));
try!(self.print_view_path(&**vp));
try!(word(&mut self.s, ";"));
try!(self.end()); // end inner head-block
@ -839,7 +839,7 @@ impl<'a> State<'a> {
}
ast::ItemStatic(ref ty, m, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"static")[]));
"static")));
if m == ast::MutMutable {
try!(self.word_space("mut"));
}
@ -856,7 +856,7 @@ impl<'a> State<'a> {
}
ast::ItemConst(ref ty, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"const")[]));
"const")));
try!(self.print_ident(item.ident));
try!(self.word_space(":"));
try!(self.print_type(&**ty));
@ -879,28 +879,28 @@ 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));
}
ast::ItemMod(ref _mod) => {
try!(self.head(&visibility_qualified(item.vis,
"mod")[]));
"mod")));
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));
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()));
try!(self.bopen());
try!(self.print_foreign_mod(nmod, &item.attrs[]));
try!(self.print_foreign_mod(nmod, &item.attrs));
try!(self.bclose(item.span));
}
ast::ItemTy(ref ty, ref params) => {
try!(self.ibox(indent_unit));
try!(self.ibox(0));
try!(self.word_nbsp(&visibility_qualified(item.vis, "type")[]));
try!(self.word_nbsp(&visibility_qualified(item.vis, "type")));
try!(self.print_ident(item.ident));
try!(self.print_generics(params));
try!(self.end()); // end the inner ibox
@ -922,7 +922,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")));
try!(self.print_struct(&**struct_def, generics, item.ident, item.span));
}
@ -963,7 +963,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));
for impl_item in impl_items {
match *impl_item {
ast::MethodImplItem(ref meth) => {
@ -1049,12 +1049,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")));
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, span)
}
pub fn print_variants(&mut self,
@ -1064,7 +1064,7 @@ impl<'a> State<'a> {
for v in variants {
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));
try!(self.ibox(indent_unit));
try!(self.print_variant(&**v));
try!(word(&mut self.s, ","));
@ -1092,7 +1092,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,
|s, field| {
match field.node.kind {
ast::NamedField(..) => panic!("unexpected named field"),
@ -1122,7 +1122,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));
try!(self.print_visibility(visibility));
try!(self.print_ident(ident));
try!(self.word_nbsp(":"));
@ -1146,7 +1146,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)));
match *tk {
parse::token::DocComment(..) => {
hardbreak(&mut self.s)
@ -1155,11 +1155,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())));
try!(space(&mut self.s));
try!(self.print_tts(&delimed.tts[]));
try!(self.print_tts(&delimed.tts));
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()))
},
ast::TtSequence(_, ref seq) => {
try!(word(&mut self.s, "$("));
@ -1169,7 +1169,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)));
}
None => {},
}
@ -1233,7 +1233,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));
try!(self.print_ty_fn(m.abi,
m.unsafety,
&*m.decl,
@ -1262,7 +1262,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));
match meth.node {
ast::MethDecl(ident,
ref generics,
@ -1280,7 +1280,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)
},
ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _),
..}) => {
@ -1874,11 +1874,11 @@ impl<'a> State<'a> {
try!(self.print_string(&a.asm, a.asm_str_style));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &a.outputs[],
try!(self.commasep(Inconsistent, &a.outputs,
|s, &(ref co, ref o, is_rw)| {
match co.slice_shift_char() {
Some(('=', operand)) if is_rw => {
try!(s.print_string(&format!("+{}", operand)[],
try!(s.print_string(&format!("+{}", operand),
ast::CookedStr))
}
_ => try!(s.print_string(&co, ast::CookedStr))
@ -1891,7 +1891,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,
|s, &(ref co, ref o)| {
try!(s.print_string(&co, ast::CookedStr));
try!(s.popen());
@ -1902,7 +1902,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,
|s, co| {
try!(s.print_string(&co, ast::CookedStr));
Ok(())
@ -1984,7 +1984,7 @@ impl<'a> State<'a> {
}
pub fn print_usize(&mut self, i: usize) -> IoResult<()> {
word(&mut self.s, &i.to_string()[])
word(&mut self.s, &i.to_string())
}
pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> {
@ -2074,7 +2074,7 @@ impl<'a> State<'a> {
}
try!(self.commasep(
Inconsistent,
&data.types[],
&data.types,
|s, ty| s.print_type(&**ty)));
comma = true;
}
@ -2097,7 +2097,7 @@ impl<'a> State<'a> {
try!(word(&mut self.s, "("));
try!(self.commasep(
Inconsistent,
&data.inputs[],
&data.inputs,
|s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ")"));
@ -2242,7 +2242,7 @@ impl<'a> State<'a> {
}
try!(self.cbox(indent_unit));
try!(self.ibox(0));
try!(self.print_outer_attributes(&arm.attrs[]));
try!(self.print_outer_attributes(&arm.attrs));
let mut first = true;
for p in &arm.pats {
if first {
@ -2491,7 +2491,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));
match param.default {
Some(ref default) => {
try!(space(&mut self.s));
@ -2752,7 +2752,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);
}
_ => ()
}
@ -2774,21 +2774,21 @@ impl<'a> State<'a> {
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)))
}
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))
}
ast::UnsignedIntLit(ut) => {
word(&mut self.s, &ast_util::uint_ty_to_string(ut, Some(i)))
}
ast::UnsuffixedIntLit(ast::Plus) => {
word(&mut self.s, &format!("{}", i)[])
word(&mut self.s, &format!("{}", i))
}
ast::UnsuffixedIntLit(ast::Minus) => {
word(&mut self.s, &format!("-{}", i)[])
word(&mut self.s, &format!("-{}", i))
}
}
}
@ -2797,7 +2797,7 @@ impl<'a> State<'a> {
&format!(
"{}{}",
&f,
&ast_util::float_ty_to_string(t)[])[])
&ast_util::float_ty_to_string(t)))
}
ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, &f[..]),
ast::LitBool(val) => {
@ -2809,7 +2809,7 @@ impl<'a> State<'a> {
escaped.extend(ascii::escape_default(ch as u8)
.map(|c| c as char));
}
word(&mut self.s, &format!("b\"{}\"", escaped)[])
word(&mut self.s, &format!("b\"{}\"", escaped))
}
}
}
@ -2850,7 +2850,7 @@ impl<'a> State<'a> {
comments::Mixed => {
assert_eq!(cmnt.lines.len(), 1);
try!(zerobreak(&mut self.s));
try!(word(&mut self.s, &cmnt.lines[0][]));
try!(word(&mut self.s, &cmnt.lines[0]));
zerobreak(&mut self.s)
}
comments::Isolated => {
@ -2868,7 +2868,7 @@ impl<'a> State<'a> {
comments::Trailing => {
try!(word(&mut self.s, " "));
if cmnt.lines.len() == 1 {
try!(word(&mut self.s, &cmnt.lines[0][]));
try!(word(&mut self.s, &cmnt.lines[0]));
hardbreak(&mut self.s)
} else {
try!(self.ibox(0));
@ -2938,7 +2938,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())
}
None => Ok(())
}
@ -2949,7 +2949,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())
}
None => Ok(())
}
@ -2964,7 +2964,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()));
}
word(&mut self.s, "fn")

2
src/libsyntax/test.rs
View File

@ -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));
if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
match i.node {

4
src/libsyntax/util/interner.rs
View File

@ -144,7 +144,7 @@ impl<T: Eq + Hash + Clone + 'static> Interner<T> {
}
pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
where Q: BorrowFrom<T> + Eq + Hash {
where T: Borrow<Q>, Q: Eq + Hash {
let map = self.map.borrow();
match (*map).get(val) {
Some(v) => Some(*v),
@ -285,7 +285,7 @@ impl StrInterner {
}
#[cfg(not(stage0))]
pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
where Q: BorrowFrom<RcStr> + Eq + Hash {
where RcStr: Borrow<Q>, Q: Eq + Hash {
match (*self.map.borrow()).get(val) {
Some(v) => Some(*v),
None => None,

2
src/test/compile-fail/cross-borrow-trait.rs
View File

@ -14,7 +14,7 @@
#![feature(box_syntax)]
struct Foo;
trait Trait : ::std::marker::MarkerTrait {}
trait Trait { fn foo(&self) {} }
impl Trait for Foo {}
pub fn main() {

2
src/test/compile-fail/destructure-trait-ref.rs
View File

@ -14,7 +14,7 @@
#![feature(box_patterns)]
#![feature(box_syntax)]
trait T : ::std::marker::MarkerTrait {}
trait T { fn foo(&self) {} }
impl T for isize {}
fn main() {

2
src/test/compile-fail/dst-bad-coerce1.rs
View File

@ -15,7 +15,7 @@ struct Fat<T: ?Sized> {
}
struct Foo;
trait Bar : ::std::marker::MarkerTrait {}
trait Bar { fn bar(&self) {} }
pub fn main() {
// With a vec of isize.

2
src/test/compile-fail/dst-bad-coerce3.rs
View File

@ -15,7 +15,7 @@ struct Fat<T: ?Sized> {
}
struct Foo;
trait Bar : ::std::marker::MarkerTrait {}
trait Bar { fn bar(&self) {} }
impl Bar for Foo {}
fn baz<'a>() {

2
src/test/compile-fail/dst-object-from-unsized-type.rs
View File

@ -10,7 +10,7 @@
// Test that we cannot create objects from unsized types.
trait Foo : ::std::marker::MarkerTrait {}
trait Foo { fn foo(&self) {} }
impl Foo for str {}
fn test1<T: ?Sized + Foo>(t: &T) {

4
src/test/compile-fail/issue-5543.rs
View File

@ -10,9 +10,7 @@
#![feature(box_syntax)]
use std::marker::MarkerTrait;
trait Foo : MarkerTrait {}
trait Foo { fn foo(&self) {} }
impl Foo for u8 {}
fn main() {

1
src/test/compile-fail/kindck-inherited-copy-bound.rs
View File

@ -15,6 +15,7 @@
use std::any::Any;
trait Foo : Copy {
fn foo(&self) {}
}
impl<T:Copy> Foo for T {

4
src/test/compile-fail/regions-close-object-into-object-5.rs
View File

@ -11,8 +11,6 @@
#![feature(box_syntax)]
#![allow(warnings)]
use std::marker::MarkerTrait;
trait A<T>
{
fn get(&self) -> T { panic!() }
@ -20,7 +18,7 @@ trait A<T>
struct B<'a, T>(&'a (A<T>+'a));
trait X : MarkerTrait {}
trait X { fn foo(&self) {} }
impl<'a, T> X for B<'a, T> {}

2
src/test/compile-fail/regions-close-param-into-object.rs
View File

@ -10,7 +10,7 @@
#![feature(box_syntax)]
trait X : ::std::marker::MarkerTrait {}
trait X { fn foo(&self) {} }
fn p1<T>(v: T) -> Box<X+'static>
where T : X

2
src/test/run-pass/borrowck-trait-lifetime.rs
View File

@ -16,7 +16,7 @@
use std::marker;
fn main() {
trait T : marker::MarkerTrait {}
trait T { fn foo(&self) {} }
fn f<'a, V: T>(v: &'a V) -> &'a T {
v as &'a T

2
src/test/run-pass/issue-14399.rs
View File

@ -19,7 +19,7 @@
#[derive(Clone)]
struct B1;
trait A : std::marker::MarkerTrait {}
trait A { fn foo(&self) {} }
impl A for B1 {}
fn main() {

3
src/test/run-pass/trait-impl.rs
View File

@ -16,7 +16,8 @@ use traitimpl::Bar;
static mut COUNT: uint = 1;
trait T : ::std::marker::MarkerTrait {
trait T {
fn foo(&self) {}
}
impl<'a> T+'a {

2
src/test/run-pass/unique-object-move.rs
View File

@ -13,7 +13,7 @@
#![allow(unknown_features)]
#![feature(box_syntax)]
pub trait EventLoop : ::std::marker::MarkerTrait { }
pub trait EventLoop { fn foo(&self) {} }
pub struct UvEventLoop {
uvio: int