---

yaml
---
r: 121535
b: refs/heads/master
c: f8e06c4
h: refs/heads/master
i:
  121533: 12f375b
  121531: 55ed371
  121527: 0a9125e
  121519: fb34608
  121503: 9e86512
  121471: 71c83e0
v: v3

Author: Sawyer47

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 389fae2ca85dc83da8deb70cc7c5acc50e87e684
+refs/heads/master: f8e06c49650afd7c9ef749baa72cb8da59880f96
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: bab614f5fa725d248afc5f0530c835f37998ce8f
 refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f

trunk/src/compiletest/runtest.rs

@@ -320,7 +320,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 
     let config = &mut config;
     let DebuggerCommands { commands, check_lines, .. } = parse_debugger_commands(testfile, "gdb");
-    let mut cmds = commands.connect("\n").to_string();
+    let mut cmds = commands.connect("\n");
 
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
@@ -1035,10 +1035,7 @@ fn compose_and_run_compiler(
             make_compile_args(config,
                               &aux_props,
                               crate_type.append(
-                                  extra_link_args.iter()
-                                                 .map(|x| x.to_string())
-                                                 .collect::<Vec<_>>()
-                                                 .as_slice()),
+                                  extra_link_args.as_slice()),
                               |a,b| {
                                   let f = make_lib_name(a, b, testfile);
                                   ThisDirectory(f.dir_path())

trunk/src/doc/guide.md

@@ -106,184 +106,4 @@ call ourselves), and we can help you out. Other great resources include our
 
 ## Hello, world!
 
-Now that you have Rust installed, let's write your first Rust program. It's
-traditional to make your first program in any new language one that prints the
-text "Hello, world!" to the screen. The nice thing about starting with such a
-simple program is that you can verify that your compiler isn't just installed,
-but also working properly. And printing information to the screen is a pretty
-common thing to do.
-
-The first thing that we need to do is make a file to put our code in. I like
-to make a projects directory in my home directory, and keep all my projects
-there. Rust does not care where your code lives.
-
-This actually leads to one other concern we should address: this tutorial will
-assume that you have basic familiarity with the command-line. Rust does not
-require that you know a whole ton about the command line, but until the
-language is in a more finished state, IDE support is spotty. Rust makes no
-specific demands on your editing tooling, or where your code lives.
-
-With that said, let's make a directory in our projects directory. Note that you
-don't need to type in the `$`s, they just indicate the start of each command:
-
-```{bash}
-$ mkdir ~/projects
-$ cd ~/projects
-$ mkdir hello_world
-$ cd hello_world
-```
-
-If you're on Windows and not using PowerShell, the `~` may not work. Consult
-the documentation for your shell for more details.
-
-Let's make a new source file next. I'm going to use the syntax `editor
-filename` to represent editing a file in these examples, but you should use
-whatever method you want. We'll call our file `hello_world.rs`:
-
-```{bash}
-$ editor hello_world.rs
-```
-
-Rust files always end in a `.rs` extension. If you're using more than one word
-in your file name, use an underscore. `hello_world.rs` versus `goodbye.rs`.
-
-Now that you've got your file open, type this in:
-
-```
-fn main() {
-    println!("Hello, world");
-}
-```
-
-Save the file, and then type this into your terminal window:
-
-```{bash}
-$ rustc hello_world.rs
-$ ./hello_world  # on Windows, this is ./hello_world.exe
-Hello, world
-```
-
-Success! Let's go over what just happened in detail.
-
-```
-fn main() {
-   
-}
-```
-
-These two lines define a **function** in Rust. The `main` function is special:
-it's the beginning of every Rust program. The first line says "I'm declaring a
-function named `main`, which takes no arguments and returns nothing." If there
-were arguments, they would go inside the parentheses (`(` and `)`), and because
-we aren't returning anything from this function, we've dropped that notation
-entirely.  We'll get to it later.
-
-You'll also note that the function is wrapped in curly braces (`{` and `}`).
-Rust requires these around all function bodies. It is also considered good
-style to put the curly brace on the same line as the function declaration, with
-one space in between.
-
-Next up is this line:
-
-```
-    println!("Hello, world");
-```
-
-This line does all of the work in our little program. There are a number of
-details that are important here. The first is that it's indented with four
-spaces, not tabs. Please configure your editor of choice to insert four spaces
-with the tab key. We provide some sample configurations for various editors
-[here](https://github.com/rust-lang/rust/tree/master/src/etc).
-
-The second point is the `println!()` part. This is calling a Rust **macro**,
-which is how metaprogramming is done in Rust. If it were a function instead, it
-would look like this: `println()`. For our purposes, we don't need to worry
-about this difference. Just know that sometimes, you'll see a `!`, and that
-means that you're calling a macro instead of a normal function.
-
-Next, `"Hello, world"` is a **string**. Strings are a surprisingly
-complicated topic in a systems programming language, and this is a **staticly
-allocated** string. We will talk more about different kinds of allocation
-later. We pass this string as an argument to `println!`, which prints the
-string to the screen. Easy enough!
-
-Finally, the line ends with a semicolon (`;`). Rust is an **expression
-oriented** language, which means that most things are expressions. The `;` is
-used to indicate that this expression is over, and the next one is ready to
-begin. Most lines of Rust code end with a `;`. We will cover this in-depth
-later in the tutorial.
-
-Finally, actually **compiling** and **running** our program. We can compile
-with our compiler, `rustc`, by passing it the name of our source file:
-
-```{bash}
-$ rustc hello_world.rs
-```
-
-This is similar to `gcc` or `clang`, if you come from a C or C++ background. Rust
-will output a binary executable. You can see it with `ls`:
-
-```{bash}
-$ ls
-hello_world  hello_world.rs
-```
-
-Or on Windows:
-
-```{bash}
-$ dir
-hello_world.exe  hello_world.rs
-```
-
-There are now two files: our source code, with the `.rs`, and the executable.
-We ran the executable like this:
-
-```{bash}
-$ ./hello_world  # or ./hello_world.exe on Windows
-```
-
-This prints out our `Hello, world!` text to our terminal.
-
-If you come from a dynamically typed language like Ruby, Python, or JavaScript,
-you may not be used to these two steps being separate. Rust is an
-**ahead-of-time compiled language**, which means that you can compile a
-program, give it to someone else, and they don't need to have Rust installed.
-If you give someone a `.rb` or `.py` or `.js` file, they need to have
-Ruby/Python/JavaScript installed, but you just need one command to both compile
-and run your program. Everything is a tradeoff in language design, and Rust has
-made its choice.
-
-Congratulations! You have officially written a Rust program. That makes you a
-Rust programmer! Welcome.
-
-Next, I'd like to introduce you to another tool, Cargo, which is used to write
-real-world Rust programs. Just using `rustc` is nice for simple things, but as
-your project grows, you'll want something to help you manage all of the options
-that it has, and to make it easy to share your code with other people and
-projects.
-
 ## Hello, Cargo!
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

trunk/src/libgetopts/lib.rs

@@ -49,9 +49,7 @@
 //! }
 //!
 //! fn main() {
-//!     let args: Vec<String> = os::args().iter()
-//!                                       .map(|x| x.to_string())
-//!                                       .collect();
+//!     let args: Vec<String> = os::args();
 //!
 //!     let program = args.get(0).clone();
 //!

trunk/src/librustc/back/link.rs

@@ -659,7 +659,7 @@ pub fn sanitize(s: &str) -> String {
     if result.len() > 0u &&
         result.as_slice()[0] != '_' as u8 &&
         ! char::is_XID_start(result.as_slice()[0] as char) {
-        return format!("_{}", result.as_slice()).to_string();
+        return format!("_{}", result.as_slice());
     }
 
     return result;

trunk/src/librustc/driver/config.rs

@@ -650,10 +650,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
     }
 
     let sysroot_opt = matches.opt_str("sysroot").map(|m| Path::new(m));
-    let target = match matches.opt_str("target") {
-        Some(supplied_target) => supplied_target.to_string(),
-        None => driver::host_triple().to_string(),
-    };
+    let target = matches.opt_str("target").unwrap_or(
+        driver::host_triple().to_string());
     let opt_level = {
         if (debugging_opts & NO_OPT) != 0 {
             No
@@ -705,10 +703,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         Path::new(s.as_slice())
     }).collect();
 
-    let cfg = parse_cfgspecs(matches.opt_strs("cfg")
-                                    .move_iter()
-                                    .map(|x| x.to_string())
-                                    .collect());
+    let cfg = parse_cfgspecs(matches.opt_strs("cfg"));
     let test = matches.opt_present("test");
     let write_dependency_info = (matches.opt_present("dep-info"),
                                  matches.opt_str("dep-info")

trunk/src/librustc/driver/driver.rs

@@ -595,7 +595,7 @@ impl pprust::PpAnn for IdentifiedAnnotation {
             }
             pprust::NodeBlock(blk) => {
                 try!(pp::space(&mut s.s));
-                s.synth_comment((format!("block {}", blk.id)).to_string())
+                s.synth_comment(format!("block {}", blk.id))
             }
             pprust::NodeExpr(expr) => {
                 try!(pp::space(&mut s.s));
@@ -604,7 +604,7 @@ impl pprust::PpAnn for IdentifiedAnnotation {
             }
             pprust::NodePat(pat) => {
                 try!(pp::space(&mut s.s));
-                s.synth_comment((format!("pat {}", pat.id)).to_string())
+                s.synth_comment(format!("pat {}", pat.id))
             }
         }
     }
@@ -752,7 +752,7 @@ fn print_flowgraph<W:io::Writer>(analysis: CrateAnalysis,
     let cfg = cfg::CFG::new(ty_cx, &*block);
     let lcfg = LabelledCFG { ast_map: &ty_cx.map,
                              cfg: &cfg,
-                             name: format!("block{}", block.id).to_string(), };
+                             name: format!("block{}", block.id), };
     debug!("cfg: {:?}", cfg);
     let r = dot::render(&lcfg, &mut out);
     return expand_err_details(r);

trunk/src/librustc/lib.rs

@@ -137,8 +137,6 @@ mod rustc {
 }
 
 pub fn main() {
-    let args = std::os::args().iter()
-                              .map(|x| x.to_string())
-                              .collect::<Vec<_>>();
+    let args = std::os::args();
     std::os::set_exit_status(driver::main_args(args.as_slice()));
 }

trunk/src/librustc/lib/llvm.rs

@@ -1894,7 +1894,7 @@ impl TypeNames {
 
     pub fn types_to_str(&self, tys: &[Type]) -> String {
         let strs: Vec<String> = tys.iter().map(|t| self.type_to_str(*t)).collect();
-        format!("[{}]", strs.connect(",").to_string())
+        format!("[{}]", strs.connect(","))
     }
 
     pub fn val_to_str(&self, val: ValueRef) -> String {

trunk/src/librustc/metadata/creader.rs

@@ -441,11 +441,11 @@ impl<'a> PluginMetadataReader<'a> {
         };
         let macros = decoder::get_exported_macros(library.metadata.as_slice());
         let registrar = decoder::get_plugin_registrar_fn(library.metadata.as_slice()).map(|id| {
-            decoder::get_symbol(library.metadata.as_slice(), id).to_string()
+            decoder::get_symbol(library.metadata.as_slice(), id)
         });
         let pc = PluginMetadata {
             lib: library.dylib.clone(),
-            macros: macros.move_iter().map(|x| x.to_string()).collect(),
+            macros: macros,
             registrar_symbol: registrar,
         };
         if should_link && existing_match(&self.env, &info.crate_id, None).is_none() {

trunk/src/librustc/middle/borrowck/mod.rs

@@ -801,37 +801,34 @@ impl DataFlowOperator for LoanDataFlowOperator {
 
 impl Repr for Loan {
     fn repr(&self, tcx: &ty::ctxt) -> String {
-        (format!("Loan_{:?}({}, {:?}, {:?}-{:?}, {})",
+        format!("Loan_{:?}({}, {:?}, {:?}-{:?}, {})",
                  self.index,
                  self.loan_path.repr(tcx),
                  self.kind,
                  self.gen_scope,
                  self.kill_scope,
-                 self.restricted_paths.repr(tcx))).to_string()
+                 self.restricted_paths.repr(tcx))
     }
 }
 
 impl Repr for LoanPath {
     fn repr(&self, tcx: &ty::ctxt) -> String {
         match self {
             &LpVar(id) => {
-                (format!("$({})", tcx.map.node_to_str(id))).to_string()
+                format!("$({})", tcx.map.node_to_str(id))
             }
 
             &LpUpvar(ty::UpvarId{ var_id, closure_expr_id }) => {
                 let s = tcx.map.node_to_str(var_id);
-                let s = format!("$({} captured by id={})", s, closure_expr_id);
-                s.to_string()
+                format!("$({} captured by id={})", s, closure_expr_id)
             }
 
             &LpExtend(ref lp, _, LpDeref(_)) => {
-                (format!("{}.*", lp.repr(tcx))).to_string()
+                format!("{}.*", lp.repr(tcx))
             }
 
             &LpExtend(ref lp, _, LpInterior(ref interior)) => {
-                (format!("{}.{}",
-                         lp.repr(tcx),
-                         interior.repr(tcx))).to_string()
+                format!("{}.{}", lp.repr(tcx), interior.repr(tcx))
             }
         }
     }

trunk/src/librustc/util/ppaux.rs

@@ -629,7 +629,7 @@ impl Repr for ty::ParamBounds {
         for t in self.trait_bounds.iter() {
             res.push(t.repr(tcx));
         }
-        res.connect("+").to_string()
+        res.connect("+")
     }
 }
 

trunk/src/librustdoc/html/markdown.rs

@@ -228,12 +228,12 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
         };
 
         // Transform the contents of the header into a hyphenated string
-        let id = (s.as_slice().words().map(|s| {
+        let id = s.as_slice().words().map(|s| {
             match s.to_ascii_opt() {
                 Some(s) => s.to_lower().into_str(),
                 None => s.to_string()
             }
-        }).collect::<Vec<String>>().connect("-")).to_string();
+        }).collect::<Vec<String>>().connect("-");
 
         // This is a terrible hack working around how hoedown gives us rendered
         // html for text rather than the raw text.
@@ -252,7 +252,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
 
         let sec = match opaque.toc_builder {
             Some(ref mut builder) => {
-                builder.push(level as u32, s.to_string(), id.clone())
+                builder.push(level as u32, s.clone(), id.clone())
             }
             None => {""}
         };