librustdoc has been updated

GuillaumeGomez · GuillaumeGomez · commit a2e01c62d5b6 · 2015-02-06T22:54:41.000+01:00
Fixes run build error

Fix test failure

Fix tests' errors
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -410,12 +410,12 @@ pub enum Attribute {
 impl Clean<Attribute> for ast::MetaItem {
     fn clean(&self, cx: &DocContext) -> Attribute {
         match self.node {
-            ast::MetaWord(ref s) => Word(s.get().to_string()),
+            ast::MetaWord(ref s) => Word(s.to_string()),
             ast::MetaList(ref s, ref l) => {
-                List(s.get().to_string(), l.clean(cx))
+                List(s.to_string(), l.clean(cx))
             }
             ast::MetaNameValue(ref s, ref v) => {
-                NameValue(s.get().to_string(), lit_to_string(v))
+                NameValue(s.to_string(), lit_to_string(v))
             }
         }
     }
@@ -700,19 +700,19 @@ impl Lifetime {
 
 impl Clean<Lifetime> for ast::Lifetime {
     fn clean(&self, _: &DocContext) -> Lifetime {
-        Lifetime(token::get_name(self.name).get().to_string())
+        Lifetime(token::get_name(self.name).to_string())
     }
 }
 
 impl Clean<Lifetime> for ast::LifetimeDef {
     fn clean(&self, _: &DocContext) -> Lifetime {
-        Lifetime(token::get_name(self.lifetime.name).get().to_string())
+        Lifetime(token::get_name(self.lifetime.name).to_string())
     }
 }
 
 impl Clean<Lifetime> for ty::RegionParameterDef {
     fn clean(&self, _: &DocContext) -> Lifetime {
-        Lifetime(token::get_name(self.name).get().to_string())
+        Lifetime(token::get_name(self.name).to_string())
     }
 }
 
@@ -721,7 +721,7 @@ impl Clean<Option<Lifetime>> for ty::Region {
         match *self {
             ty::ReStatic => Some(Lifetime::statik()),
             ty::ReLateBound(_, ty::BrNamed(_, name)) =>
-                Some(Lifetime(token::get_name(name).get().to_string())),
+                Some(Lifetime(token::get_name(name).to_string())),
             ty::ReEarlyBound(_, _, _, name) => Some(Lifetime(name.clean(cx))),
 
             ty::ReLateBound(..) |
@@ -1953,20 +1953,20 @@ fn path_to_string(p: &ast::Path) -> String {
         } else {
             first = false;
         }
-        s.push_str(i.get());
+        s.push_str(&i);
     }
     s
 }
 
 impl Clean<String> for ast::Ident {
     fn clean(&self, _: &DocContext) -> String {
-        token::get_ident(*self).get().to_string()
+        token::get_ident(*self).to_string()
     }
 }
 
 impl Clean<String> for ast::Name {
     fn clean(&self, _: &DocContext) -> String {
-        token::get_name(*self).get().to_string()
+        token::get_name(*self).to_string()
     }
 }
 
@@ -2158,7 +2158,7 @@ impl Clean<Vec<Item>> for doctree::Import {
         // forcefully don't inline if this is not public or if the
         // #[doc(no_inline)] attribute is present.
         let denied = self.vis != ast::Public || self.attrs.iter().any(|a| {
-            a.name().get() == "doc" && match a.meta_item_list() {
+            &a.name()[] == "doc" && match a.meta_item_list() {
                 Some(l) => attr::contains_name(l, "no_inline"),
                 None => false,
             }
@@ -2311,7 +2311,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::LitStr(ref st, _) => st.to_string(),
         ast::LitBinary(ref data) => format!("{:?}", data),
         ast::LitByte(b) => {
             let mut res = String::from_str("b'");
@@ -2323,8 +2323,8 @@ fn lit_to_string(lit: &ast::Lit) -> String {
         },
         ast::LitChar(c) => format!("'{}'", c),
         ast::LitInt(i, _t) => i.to_string(),
-        ast::LitFloat(ref f, _t) => f.get().to_string(),
-        ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),
+        ast::LitFloat(ref f, _t) => f.to_string(),
+        ast::LitFloatUnsuffixed(ref f) => f.to_string(),
         ast::LitBool(b) => b.to_string(),
     }
 }
@@ -2336,7 +2336,7 @@ fn name_from_pat(p: &ast::Pat) -> String {
     match p.node {
         PatWild(PatWildSingle) => "_".to_string(),
         PatWild(PatWildMulti) => "..".to_string(),
-        PatIdent(_, ref p, _) => token::get_ident(p.node).get().to_string(),
+        PatIdent(_, ref p, _) => token::get_ident(p.node).to_string(),
         PatEnum(ref p, _) => path_to_string(p),
         PatStruct(ref name, ref fields, etc) => {
             format!("{} {{ {}{} }}", path_to_string(name),
@@ -2486,11 +2486,11 @@ impl Clean<Stability> for attr::Stability {
     fn clean(&self, _: &DocContext) -> Stability {
         Stability {
             level: self.level,
-            feature: self.feature.get().to_string(),
+            feature: self.feature.to_string(),
             since: self.since.as_ref().map_or("".to_string(),
-                                              |interned| interned.get().to_string()),
+                                              |interned| interned.to_string()),
             reason: self.reason.as_ref().map_or("".to_string(),
-                                                |interned| interned.get().to_string()),
+                                                |interned| interned.to_string()),
         }
     }
 }
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
@@ -142,7 +142,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader,
 
             // keywords are also included in the identifier set
             token::Ident(ident, _is_mod_sep) => {
-                match token::get_ident(ident).get() {
+                match &token::get_ident(ident)[] {
                     "ref" | "mut" => "kw-2",
 
                     "self" => "self",
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
@@ -237,7 +237,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             ast::ItemExternCrate(ref p) => {
                 let path = match *p {
                     None => None,
-                    Some((ref x, _)) => Some(x.get().to_string()),
+                    Some((ref x, _)) => Some(x.to_string()),
                 };
                 om.extern_crates.push(ExternCrate {
                     name: name,
@@ -253,7 +253,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                     let please_inline = item.attrs.iter().any(|item| {
                         match item.meta_item_list() {
                             Some(list) => {
-                                list.iter().any(|i| i.name().get() == "inline")
+                                list.iter().any(|i| &i.name()[] == "inline")
                             }
                             None => false,
                         }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -1862,7 +1862,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.get());
+                    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));
@@ -1915,7 +1915,7 @@ foo_module!();
         let cxbinds: Vec<&ast::Ident> =
             bindings.iter().filter(|b| {
                 let ident = token::get_ident(**b);
-                let string = ident.get();
+                let string = &ident[];
                 "xx" == string
             }).collect();
         let cxbinds: &[&ast::Ident] = &cxbinds[];
@@ -1929,7 +1929,7 @@ foo_module!();
         // the xx binding should bind all of the xx varrefs:
         for (idx,v) in varrefs.iter().filter(|p| {
             p.segments.len() == 1
-            && "xx" == token::get_ident(p.segments[0].identifier).get()
+            && "xx" == &token::get_ident(p.segments[0].identifier)[]
         }).enumerate() {
             if mtwt::resolve(v.segments[0].identifier) != resolved_binding {
                 println!("uh oh, xx binding didn't match xx varref:");
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -1201,19 +1201,19 @@ mod test {
         let source = "/// doc comment\r\nfn foo() {}".to_string();
         let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
         let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
-        assert_eq!(doc.get(), "/// doc comment");
+        assert_eq!(&doc[], "/// doc comment");
 
         let source = "/// doc comment\r\n/// line 2\r\nfn foo() {}".to_string();
         let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
-        let docs = item.attrs.iter().filter(|a| a.name().get() == "doc")
-                    .map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>();
+        let docs = item.attrs.iter().filter(|a| &a.name()[] == "doc")
+                    .map(|a| a.value_str().unwrap().to_string()).collect::<Vec<_>>();
         let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
         assert_eq!(&docs[], 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();
         let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
-        assert_eq!(doc.get(), "/** doc comment\n *  with CRLF */");
+        assert_eq!(&doc[], "/** doc comment\n *  with CRLF */");
     }
 
     #[test]
diff --git a/src/test/auxiliary/lint_group_plugin_test.rs b/src/test/auxiliary/lint_group_plugin_test.rs
@@ -37,9 +37,9 @@ impl LintPass for Pass {
 
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
         let name = token::get_ident(it.ident);
-        if name.get() == "lintme" {
+        if &name[] == "lintme" {
             cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
-        } else if name.get() == "pleaselintme" {
+        } else if &name[] == "pleaselintme" {
             cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'");
         }
     }
diff --git a/src/test/auxiliary/lint_plugin_test.rs b/src/test/auxiliary/lint_plugin_test.rs
@@ -35,7 +35,7 @@ impl LintPass for Pass {
 
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
         let name = token::get_ident(it.ident);
-        if name.get() == "lintme" {
+        if &name[] == "lintme" {
             cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
         }
     }
diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs
@@ -1,3 +1,5 @@
+// no-prefer-dynamic
+
 // 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.

Original file line number	Diff line number	Diff line change
`@@ -410,12 +410,12 @@ pub enum Attribute {`
`410`	`410`	`impl Clean<Attribute> for ast::MetaItem {`
`411`	`411`	`fn clean(&self, cx: &DocContext) -> Attribute {`
`412`	`412`	`match self.node {`
`413`		`- ast::MetaWord(ref s) => Word(s.get().to_string()),`
	`413`	`+ ast::MetaWord(ref s) => Word(s.to_string()),`
`414`	`414`	`ast::MetaList(ref s, ref l) => {`
`415`		`- List(s.get().to_string(), l.clean(cx))`
	`415`	`+ List(s.to_string(), l.clean(cx))`
`416`	`416`	`}`
`417`	`417`	`ast::MetaNameValue(ref s, ref v) => {`
`418`		`- NameValue(s.get().to_string(), lit_to_string(v))`
	`418`	`+ NameValue(s.to_string(), lit_to_string(v))`
`419`	`419`	`}`
`420`	`420`	`}`
`421`	`421`	`}`
`@@ -700,19 +700,19 @@ impl Lifetime {`
`700`	`700`
`701`	`701`	`impl Clean<Lifetime> for ast::Lifetime {`
`702`	`702`	`fn clean(&self, _: &DocContext) -> Lifetime {`
`703`		`- Lifetime(token::get_name(self.name).get().to_string())`
	`703`	`+ Lifetime(token::get_name(self.name).to_string())`
`704`	`704`	`}`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`impl Clean<Lifetime> for ast::LifetimeDef {`
`708`	`708`	`fn clean(&self, _: &DocContext) -> Lifetime {`
`709`		`- Lifetime(token::get_name(self.lifetime.name).get().to_string())`
	`709`	`+ Lifetime(token::get_name(self.lifetime.name).to_string())`
`710`	`710`	`}`
`711`	`711`	`}`
`712`	`712`
`713`	`713`	`impl Clean<Lifetime> for ty::RegionParameterDef {`
`714`	`714`	`fn clean(&self, _: &DocContext) -> Lifetime {`
`715`		`- Lifetime(token::get_name(self.name).get().to_string())`
	`715`	`+ Lifetime(token::get_name(self.name).to_string())`
`716`	`716`	`}`
`717`	`717`	`}`
`718`	`718`
`@@ -721,7 +721,7 @@ impl Clean<Option<Lifetime>> for ty::Region {`
`721`	`721`	`match *self {`
`722`	`722`	`ty::ReStatic => Some(Lifetime::statik()),`
`723`	`723`	`ty::ReLateBound(_, ty::BrNamed(_, name)) =>`
`724`		`- Some(Lifetime(token::get_name(name).get().to_string())),`
	`724`	`+ Some(Lifetime(token::get_name(name).to_string())),`
`725`	`725`	`ty::ReEarlyBound(_, _, _, name) => Some(Lifetime(name.clean(cx))),`
`726`	`726`
`727`	`727`	`ty::ReLateBound(..) \|`
`@@ -1953,20 +1953,20 @@ fn path_to_string(p: &ast::Path) -> String {`
`1953`	`1953`	`} else {`
`1954`	`1954`	`first = false;`
`1955`	`1955`	`}`
`1956`		`- s.push_str(i.get());`
	`1956`	`+ s.push_str(&i);`
`1957`	`1957`	`}`
`1958`	`1958`	`s`
`1959`	`1959`	`}`
`1960`	`1960`
`1961`	`1961`	`impl Clean<String> for ast::Ident {`
`1962`	`1962`	`fn clean(&self, _: &DocContext) -> String {`
`1963`		`- token::get_ident(*self).get().to_string()`
	`1963`	`+ token::get_ident(*self).to_string()`
`1964`	`1964`	`}`
`1965`	`1965`	`}`
`1966`	`1966`
`1967`	`1967`	`impl Clean<String> for ast::Name {`
`1968`	`1968`	`fn clean(&self, _: &DocContext) -> String {`
`1969`		`- token::get_name(*self).get().to_string()`
	`1969`	`+ token::get_name(*self).to_string()`
`1970`	`1970`	`}`
`1971`	`1971`	`}`
`1972`	`1972`
`@@ -2158,7 +2158,7 @@ impl Clean<Vec<Item>> for doctree::Import {`
`2158`	`2158`	`// forcefully don't inline if this is not public or if the`
`2159`	`2159`	`// #[doc(no_inline)] attribute is present.`
`2160`	`2160`	`let denied = self.vis != ast::Public \|\| self.attrs.iter().any(\|a\| {`
`2161`		`- a.name().get() == "doc" && match a.meta_item_list() {`
	`2161`	`+ &a.name()[] == "doc" && match a.meta_item_list() {`
`2162`	`2162`	`Some(l) => attr::contains_name(l, "no_inline"),`
`2163`	`2163`	`None => false,`
`2164`	`2164`	`}`
`@@ -2311,7 +2311,7 @@ impl ToSource for syntax::codemap::Span {`
`2311`	`2311`
`2312`	`2312`	`fn lit_to_string(lit: &ast::Lit) -> String {`
`2313`	`2313`	`match lit.node {`
`2314`		`- ast::LitStr(ref st, _) => st.get().to_string(),`
	`2314`	`+ ast::LitStr(ref st, _) => st.to_string(),`
`2315`	`2315`	`ast::LitBinary(ref data) => format!("{:?}", data),`
`2316`	`2316`	`ast::LitByte(b) => {`
`2317`	`2317`	`let mut res = String::from_str("b'");`
`@@ -2323,8 +2323,8 @@ fn lit_to_string(lit: &ast::Lit) -> String {`
`2323`	`2323`	`},`
`2324`	`2324`	`ast::LitChar(c) => format!("'{}'", c),`
`2325`	`2325`	`ast::LitInt(i, _t) => i.to_string(),`
`2326`		`- ast::LitFloat(ref f, _t) => f.get().to_string(),`
`2327`		`- ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),`
	`2326`	`+ ast::LitFloat(ref f, _t) => f.to_string(),`
	`2327`	`+ ast::LitFloatUnsuffixed(ref f) => f.to_string(),`
`2328`	`2328`	`ast::LitBool(b) => b.to_string(),`
`2329`	`2329`	`}`
`2330`	`2330`	`}`
`@@ -2336,7 +2336,7 @@ fn name_from_pat(p: &ast::Pat) -> String {`
`2336`	`2336`	`match p.node {`
`2337`	`2337`	`PatWild(PatWildSingle) => "_".to_string(),`
`2338`	`2338`	`PatWild(PatWildMulti) => "..".to_string(),`
`2339`		`- PatIdent(_, ref p, _) => token::get_ident(p.node).get().to_string(),`
	`2339`	`+ PatIdent(_, ref p, _) => token::get_ident(p.node).to_string(),`
`2340`	`2340`	`PatEnum(ref p, _) => path_to_string(p),`
`2341`	`2341`	`PatStruct(ref name, ref fields, etc) => {`
`2342`	`2342`	`format!("{} {{ {}{} }}", path_to_string(name),`
`@@ -2486,11 +2486,11 @@ impl Clean<Stability> for attr::Stability {`
`2486`	`2486`	`fn clean(&self, _: &DocContext) -> Stability {`
`2487`	`2487`	`Stability {`
`2488`	`2488`	`level: self.level,`
`2489`		`- feature: self.feature.get().to_string(),`
	`2489`	`+ feature: self.feature.to_string(),`
`2490`	`2490`	`since: self.since.as_ref().map_or("".to_string(),`
`2491`		`- \|interned\| interned.get().to_string()),`
	`2491`	`+ \|interned\| interned.to_string()),`
`2492`	`2492`	`reason: self.reason.as_ref().map_or("".to_string(),`
`2493`		`- \|interned\| interned.get().to_string()),`
	`2493`	`+ \|interned\| interned.to_string()),`
`2494`	`2494`	`}`
`2495`	`2495`	`}`
`2496`	`2496`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,9 +37,9 @@ impl LintPass for Pass {`
`37`	`37`
`38`	`38`	`fn check_item(&mut self, cx: &Context, it: &ast::Item) {`
`39`	`39`	`let name = token::get_ident(it.ident);`
`40`		`- if name.get() == "lintme" {`
	`40`	`+ if &name[] == "lintme" {`
`41`	`41`	`cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");`
`42`		`- } else if name.get() == "pleaselintme" {`
	`42`	`+ } else if &name[] == "pleaselintme" {`
`43`	`43`	`cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'");`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ impl LintPass for Pass {`
`35`	`35`
`36`	`36`	`fn check_item(&mut self, cx: &Context, it: &ast::Item) {`
`37`	`37`	`let name = token::get_ident(it.ident);`
`38`		`- if name.get() == "lintme" {`
	`38`	`+ if &name[] == "lintme" {`
`39`	`39`	`cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// no-prefer-dynamic`
	`2`	`+`
`1`	`3`	`// Copyright 2014 The Rust Project Developers. See the COPYRIGHT`
`2`	`4`	`// file at the top-level directory of this distribution and at`
`3`	`5`	`// http://rust-lang.org/COPYRIGHT.`