---

yaml
---
r: 39635
b: refs/heads/incoming
c: 47cd1e4
h: refs/heads/master
i:
  39633: 27ea39d
  39631: ed0e000
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: 624421aa3d5d09fd59834c524f1909120685232d
+refs/heads/incoming: 47cd1e4fc8e8f3cdab7d8b5864a8f2733c016cd4
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/librustc/middle/resolve.rs

@@ -2086,11 +2086,8 @@ impl Resolver {
             match self.resolve_import_for_module(module_, import_directive) {
                 Failed => {
                     // We presumably emitted an error. Continue.
-                    let idents = import_directive.module_path.get();
-                    let msg = fmt!("failed to resolve import: %s",
-                                   self.import_path_to_str(idents,
-                                   *import_directive.subclass));
-                    self.session.span_err(import_directive.span, msg);
+                    self.session.span_err(import_directive.span,
+                                          ~"failed to resolve import");
                 }
                 Indeterminate => {
                     // Bail out. We'll come around next time.
@@ -2106,29 +2103,20 @@ impl Resolver {
     }
 
     fn idents_to_str(idents: ~[ident]) -> ~str {
-        let ident_strs = idents.map(|&ident| self.session.str_of(ident));
-        return str::connect(ident_strs, "::");
-    }
-
-    fn import_directive_subclass_to_str(subclass: ImportDirectiveSubclass)
-                                                                     -> ~str {
-        match subclass {
-            SingleImport(_target, source, _ns) => self.session.str_of(source),
-            GlobImport => ~"*"
-        }
-    }
-
-    fn import_path_to_str(idents: ~[ident], subclass: ImportDirectiveSubclass)
-                                                                     -> ~str {
-        if idents.is_empty() {
-            self.import_directive_subclass_to_str(subclass)
-        } else {
-            fmt!("%s::%s",
-                 self.idents_to_str(idents),
-                 self.import_directive_subclass_to_str(subclass))
-        }
+        // XXX: str::connect should do this.
+        let mut result = ~"";
+        let mut first = true;
+        for idents.each() |ident| {
+            if first {
+                first = false;
+            } else {
+                result += ~"::";
+            }
+            result += self.session.str_of(*ident);
+        }
+        // XXX: Shouldn't copy here. We need string builder functionality.
+        return result;
     }
-
     /**
      * Attempts to resolve the given import. The return value indicates
      * failure if we're certain the name does not exist, indeterminate if we
@@ -4513,14 +4501,17 @@ impl Resolver {
                         // Write the result into the def map.
                         debug!("(resolving type) writing resolution for `%s` \
                                 (id %d)",
-                               self.idents_to_str(path.idents),
+                               connect(path.idents.map(
+                                   |x| self.session.str_of(*x)), ~"::"),
                                path_id);
                         self.record_def(path_id, def);
                     }
                     None => {
                         self.session.span_err
                             (ty.span, fmt!("use of undeclared type name `%s`",
-                                           self.idents_to_str(path.idents)));
+                                           connect(path.idents.map(
+                                               |x| self.session.str_of(*x)),
+                                                   ~"::")));
                     }
                 }
             }
@@ -4714,7 +4705,9 @@ impl Resolver {
                             self.session.span_err(
                                 path.span,
                                 fmt!("`%s` does not name a structure",
-                                     self.idents_to_str(path.idents)));
+                                     connect(path.idents.map(
+                                         |x| self.session.str_of(*x)),
+                                             ~"::")));
                         }
                     }
                 }
@@ -5110,11 +5103,14 @@ impl Resolver {
                     Some(def) => {
                         // Write the result into the def map.
                         debug!("(resolving expr) resolved `%s`",
-                               self.idents_to_str(path.idents));
+                               connect(path.idents.map(
+                                   |x| self.session.str_of(*x)), ~"::"));
                         self.record_def(expr.id, def);
                     }
                     None => {
-                        let wrong_name = self.idents_to_str(path.idents);
+                        let wrong_name =
+                            connect(path.idents.map(
+                                |x| self.session.str_of(*x)), ~"::") ;
                         if self.name_exists_in_scope_struct(wrong_name) {
                             self.session.span_err(expr.span,
                                         fmt!("unresolved name: `%s`. \
@@ -5174,7 +5170,9 @@ impl Resolver {
                         self.session.span_err(
                             path.span,
                             fmt!("`%s` does not name a structure",
-                                 self.idents_to_str(path.idents)));
+                                 connect(path.idents.map(
+                                     |x| self.session.str_of(*x)),
+                                         ~"::")));
                     }
                 }
 
@@ -5493,7 +5491,7 @@ impl Resolver {
     // hit.
     //
 
-    /// A somewhat inefficient routine to obtain the name of a module.
+    /// A somewhat inefficient routine to print out the name of a module.
     fn module_to_str(module_: @Module) -> ~str {
         let idents = DVec();
         let mut current_module = module_;
@@ -5516,7 +5514,22 @@ impl Resolver {
         if idents.len() == 0 {
             return ~"???";
         }
-        return self.idents_to_str(vec::reversed(idents.get()));
+
+        let mut string = ~"";
+        let mut i = idents.len() - 1;
+        loop {
+            if i < idents.len() - 1 {
+                string += ~"::";
+            }
+            string += self.session.str_of(idents.get_elt(i));
+
+            if i == 0 {
+                break;
+            }
+            i -= 1;
+        }
+
+        return string;
     }
 
     fn dump_module(module_: @Module) {

branches/incoming/src/librustdoc/astsrv.rs

@@ -21,6 +21,7 @@ use parse;
 use util;
 
 use core::oldcomm;
+use core::vec;
 use rustc::back::link;
 use rustc::driver::driver;
 use rustc::driver::session::Session;

branches/incoming/src/librustdoc/attr_parser.rs

@@ -31,6 +31,9 @@ pub type CrateAttrs = {
 mod test {
     #[legacy_exports];
 
+    use syntax::ast;
+    use syntax;
+
     fn parse_attributes(+source: ~str) -> ~[ast::attribute] {
         use syntax::parse;
         use syntax::parse::parser;

branches/incoming/src/librustdoc/attr_pass.rs

@@ -310,6 +310,11 @@ fn should_extract_impl_method_docs() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use doc;
+    use extract;
+
     fn mk_doc(source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, ~"");

branches/incoming/src/librustdoc/desc_to_brief_pass.rs

@@ -100,6 +100,12 @@ fn should_promote_impl_method_desc() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use attr_pass;
+    use doc;
+    use extract;
+
     fn mk_doc(source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, ~"");

branches/incoming/src/librustdoc/extract.rs

@@ -344,6 +344,12 @@ fn should_extract_struct_fields() {
 mod test {
     #[legacy_exports];
 
+    use astsrv;
+    use doc;
+    use parse;
+
+    use core::vec;
+
     fn mk_doc(+source: ~str) -> doc::Doc {
         let ast = parse::from_str(source);
         extract(ast, ~"")

branches/incoming/src/librustdoc/fold.rs

@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use astsrv;
 use doc;
+use extract;
+use parse;
 
 use core::vec;
 use std::par;

branches/incoming/src/librustdoc/markdown_index_pass.rs

@@ -252,6 +252,15 @@ fn should_index_foreign_mod_contents() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use attr_pass;
+    use config;
+    use desc_to_brief_pass;
+    use doc;
+    use extract;
+    use path_pass;
+
     fn mk_doc(output_style: config::OutputStyle, +source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let config = {

branches/incoming/src/librustdoc/markdown_pass.rs

@@ -11,15 +11,28 @@
 //! Generate markdown from a document tree
 
 use astsrv;
+use attr_pass;
+use config;
+use desc_to_brief_pass;
 use doc::ItemUtils;
 use doc;
+use extract;
 use fold;
+use markdown_index_pass;
 use markdown_pass;
 use markdown_writer::Writer;
 use markdown_writer::WriterUtils;
 use markdown_writer::WriterFactory;
+use markdown_writer;
+use page_pass;
+use path_pass;
+use sectionalize_pass;
 use sort_pass;
+use trim_pass;
+use unindent_pass;
 
+use core::iter;
+use core::oldcomm;
 use core::str;
 use core::vec;
 use std::par;
@@ -817,6 +830,24 @@ fn should_write_struct_header() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use attr_pass;
+    use config;
+    use desc_to_brief_pass;
+    use doc;
+    use extract;
+    use markdown_index_pass;
+    use markdown_writer;
+    use path_pass;
+    use sectionalize_pass;
+    use trim_pass;
+    use tystr_pass;
+    use unindent_pass;
+
+    use core::oldcomm;
+    use core::str;
+
     fn render(+source: ~str) -> ~str {
         let (srv, doc) = create_doc_srv(source);
         let markdown = write_markdown_str_srv(srv, doc);

branches/incoming/src/librustdoc/markdown_writer.rs

@@ -267,6 +267,12 @@ fn should_name_mod_file_names_by_path() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use doc;
+    use extract;
+    use path_pass;
+
     fn mk_doc(+name: ~str, +source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, name);

branches/incoming/src/librustdoc/page_pass.rs

@@ -183,6 +183,12 @@ fn should_remove_foreign_mods_from_containing_mods() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use config;
+    use doc;
+    use extract;
+
     fn mk_doc_(
         output_style: config::OutputStyle,
         source: ~str

branches/incoming/src/librustdoc/pass.rs

@@ -10,6 +10,7 @@
 
 use astsrv;
 use doc;
+use extract;
 
 use core::vec;
 

branches/incoming/src/librustdoc/path_pass.rs

@@ -13,6 +13,7 @@
 use astsrv;
 use doc::ItemUtils;
 use doc;
+use extract;
 use fold::Fold;
 use fold;
 

branches/incoming/src/librustdoc/prune_hidden_pass.rs

@@ -71,6 +71,11 @@ fn should_prune_hidden_items() {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use astsrv;
+    use doc;
+    use extract;
+
     fn mk_doc(source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, ~"");

branches/incoming/src/librustdoc/prune_private_pass.rs

@@ -18,6 +18,7 @@ use fold::Fold;
 use fold;
 
 use core::util;
+use core::vec;
 use syntax::ast;
 
 export mk_pass;
@@ -75,6 +76,10 @@ fn should_prune_items_without_pub_modifier() {
 
 #[cfg(test)]
 mod test {
+    use astsrv;
+    use doc;
+    use extract;
+
     pub fn mk_doc(source: ~str) -> doc::Doc {
         do astsrv::from_str(source) |srv| {
             let doc = extract::from_srv(srv, ~"");

branches/incoming/src/librustdoc/sectionalize_pass.rs

@@ -11,12 +11,15 @@
 //! Breaks rustdocs into sections according to their headers
 
 use astsrv;
+use attr_pass;
 use doc::ItemUtils;
 use doc;
+use extract;
 use fold::Fold;
 use fold;
 
 use core::str;
+use core::vec;
 use std::par;
 
 pub fn mk_pass() -> Pass {

branches/incoming/src/librustdoc/sort_pass.rs

@@ -13,6 +13,7 @@
 use astsrv;
 use doc::ItemUtils;
 use doc;
+use extract;
 use fold::Fold;
 use fold;
 use util::NominalOp;