---

yaml
---
r: 273133
b: refs/heads/beta
c: 7366034
h: refs/heads/master
i:
  273131: 794f6eb

Author: aturon

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 6d215fe04ce3f638d717d7fcea95c40d0a655ff9
+refs/heads/beta: 736603424e48db41e1f2e3ad58e67809ab608a33
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/librustc/middle/traits/select.rs

@@ -836,8 +836,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             return Ok(None);
         }
 
-
-        // If there are *NO* candidates, that there are no impls --
+        // If there are *NO* candidates, then there are no impls --
         // that we know of, anyway. Note that in the case where there
         // are unbound type variables within the obligation, it might
         // be the case that you could still satisfy the obligation

branches/beta/src/librustc/session/config.rs

@@ -172,20 +172,16 @@ pub enum PrintRequest {
 pub enum Input {
     /// Load source from file
     File(PathBuf),
-    Str {
-        /// String that is shown in place of a filename
-        name: String,
-        /// Anonymous source string
-        input: String,
-    },
+    /// The string is the source
+    Str(String)
 }
 
 impl Input {
     pub fn filestem(&self) -> String {
         match *self {
             Input::File(ref ifile) => ifile.file_stem().unwrap()
                                            .to_str().unwrap().to_string(),
-            Input::Str { .. } => "rust_out".to_string(),
+            Input::Str(_) => "rust_out".to_string(),
         }
     }
 }

branches/beta/src/librustc_driver/driver.rs

@@ -231,6 +231,7 @@ pub fn compile_input(sess: &Session,
     Ok(())
 }
 
+
 /// The name used for source code that doesn't originate in a file
 /// (e.g. source from stdin or a string)
 pub fn anon_src() -> String {
@@ -241,7 +242,7 @@ pub fn source_name(input: &Input) -> String {
     match *input {
         // FIXME (#9639): This needs to handle non-utf8 paths
         Input::File(ref ifile) => ifile.to_str().unwrap().to_string(),
-        Input::Str { ref name, .. } => name.clone(),
+        Input::Str(_) => anon_src(),
     }
 }
 
@@ -433,9 +434,9 @@ pub fn phase_1_parse_input<'a>(sess: &'a Session,
             Input::File(ref file) => {
                 parse::parse_crate_from_file(file, cfg.clone(), &sess.parse_sess)
             }
-            Input::Str { ref input, ref name } => {
-                parse::parse_crate_from_source_str(name.clone(),
-                                                   input.clone(),
+            Input::Str(ref src) => {
+                parse::parse_crate_from_source_str(anon_src().to_string(),
+                                                   src.to_string(),
                                                    cfg.clone(),
                                                    &sess.parse_sess)
             }

branches/beta/src/librustc_driver/lib.rs

@@ -223,8 +223,7 @@ fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>)> {
         if ifile == "-" {
             let mut src = String::new();
             io::stdin().read_to_string(&mut src).unwrap();
-            Some((Input::Str { name: driver::anon_src(), input: src },
-                  None))
+            Some((Input::Str(src), None))
         } else {
             Some((Input::File(PathBuf::from(ifile)),
                   Some(PathBuf::from(ifile))))
@@ -512,7 +511,7 @@ impl RustcDefaultCalls {
                         .unwrap();
                     println!("{}", String::from_utf8(v).unwrap());
                 }
-                &Input::Str { .. } => {
+                &Input::Str(_) => {
                     early_error(ErrorOutputType::default(), "cannot list metadata for stdin");
                 }
             }
@@ -995,9 +994,9 @@ fn parse_crate_attrs<'a>(sess: &'a Session, input: &Input) -> PResult<'a, Vec<as
         Input::File(ref ifile) => {
             parse::parse_crate_attrs_from_file(ifile, Vec::new(), &sess.parse_sess)
         }
-        Input::Str { ref name, ref input } => {
-            parse::parse_crate_attrs_from_source_str(name.clone(),
-                                                     input.clone(),
+        Input::Str(ref src) => {
+            parse::parse_crate_attrs_from_source_str(driver::anon_src().to_string(),
+                                                     src.to_string(),
                                                      Vec::new(),
                                                      &sess.parse_sess)
         }

branches/beta/src/librustc_driver/test.rs

@@ -113,10 +113,7 @@ fn test_env<F>(source_string: &str,
                                        Rc::new(CodeMap::new()), cstore.clone());
     rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
     let krate_config = Vec::new();
-    let input = config::Input::Str {
-        name: driver::anon_src(),
-        input: source_string.to_string(),
-    };
+    let input = config::Input::Str(source_string.to_string());
     let krate = driver::phase_1_parse_input(&sess, krate_config, &input).unwrap();
     let krate = driver::phase_2_configure_and_expand(&sess, &cstore, krate, "test", None)
                     .expect("phase 2 aborted");

branches/beta/src/librustdoc/clean/mod.rs

@@ -205,7 +205,7 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
                     current_dir().unwrap().join(path)
                 }
             },
-            Input::Str { ref name, .. } => PathBuf::from(name.clone()),
+            Input::Str(_) => PathBuf::new() // FIXME: this is wrong
         };
 
         Crate {

branches/beta/src/librustdoc/test.rs

@@ -180,10 +180,7 @@ fn runtest(test: &str, cratename: &str, cfgs: Vec<String>, libs: SearchPaths,
     // the test harness wants its own `main` & top level functions, so
     // never wrap the test in `fn main() { ... }`
     let test = maketest(test, Some(cratename), as_test_harness, opts);
-    let input = config::Input::Str {
-        name: driver::anon_src(),
-        input: test.to_owned(),
-    };
+    let input = config::Input::Str(test.to_string());
     let mut outputs = HashMap::new();
     outputs.insert(OutputType::Exe, None);
 

branches/beta/src/test/run-make/execution-engine/test.rs

@@ -216,10 +216,7 @@ fn build_exec_options(sysroot: PathBuf) -> Options {
 /// for crates used in the given input.
 fn compile_program(input: &str, sysroot: PathBuf)
                    -> Option<(llvm::ModuleRef, Vec<PathBuf>)> {
-    let input = Input::Str {
-        name: driver::anon_src(),
-        input: input.to_string(),
-    };
+    let input = Input::Str(input.to_string());
     let thread = Builder::new().name("compile_program".to_string());
 
     let handle = thread.spawn(move || {

branches/beta/src/test/run-make/issue-19371/foo.rs

@@ -18,7 +18,7 @@ extern crate syntax;
 
 use rustc::session::{build_session, Session};
 use rustc::session::config::{basic_options, build_configuration, Input, OutputType};
-use rustc_driver::driver::{compile_input, CompileController, anon_src};
+use rustc_driver::driver::{compile_input, CompileController};
 use rustc_metadata::cstore::CStore;
 use syntax::diagnostics::registry::Registry;
 use syntax::parse::token;
@@ -67,7 +67,7 @@ fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
 
     compile_input(&sess, &cstore,
             cfg,
-            &Input::Str { name: anon_src(), input: code },
+            &Input::Str(code),
             &None,
             &Some(output),
             None,