inform user where to give a type annotation after a call to collect

config.toml.example

@@ -312,11 +312,6 @@
 # bootstrap)
 #codegen-backends = ["llvm"]
 
-# Flag indicating whether `libstd` calls an imported function to hande basic IO
-# when targetting WebAssembly. Enable this to debug tests for the `wasm32-unknown-unknown`
-# target, as without this option the test output will not be captured.
-#wasm-syscall = false
-
 # =============================================================================
 # Options for specific targets
 #

src/bootstrap/builder.rs

@@ -377,11 +377,6 @@ impl<'a> Builder<'a> {
         self.ensure(Libdir { compiler, target })
     }
 
-    pub fn sysroot_codegen_backends(&self, compiler: Compiler) -> PathBuf {
-        self.sysroot_libdir(compiler, compiler.host)
-            .with_file_name("codegen-backends")
-    }
-
     /// Returns the compiler's libdir where it stores the dynamic libraries that
     /// it itself links against.
     ///
@@ -474,18 +469,6 @@ impl<'a> Builder<'a> {
             stage = compiler.stage;
         }
 
-        let mut extra_args = env::var(&format!("RUSTFLAGS_STAGE_{}", stage)).unwrap_or_default();
-        if stage != 0 {
-            let s = env::var("RUSTFLAGS_STAGE_NOT_0").unwrap_or_default();
-            extra_args.push_str(" ");
-            extra_args.push_str(&s);
-        }
-
-        if !extra_args.is_empty() {
-            cargo.env("RUSTFLAGS",
-                format!("{} {}", env::var("RUSTFLAGS").unwrap_or_default(), extra_args));
-        }
-
         // Customize the compiler we're running. Specify the compiler to cargo
         // as our shim and then pass it some various options used to configure
         // how the actual compiler itself is called.

src/bootstrap/compile.rs

@@ -724,7 +724,8 @@ fn copy_codegen_backends_to_sysroot(builder: &Builder,
     //
     // Here we're looking for the output dylib of the `CodegenBackend` step and
     // we're copying that into the `codegen-backends` folder.
-    let dst = builder.sysroot_codegen_backends(target_compiler);
+    let libdir = builder.sysroot_libdir(target_compiler, target);
+    let dst = libdir.join("codegen-backends");
     t!(fs::create_dir_all(&dst));
 
     for backend in builder.config.rust_codegen_backends.iter() {

src/bootstrap/config.rs

@@ -107,7 +107,6 @@ pub struct Config {
     pub debug_jemalloc: bool,
     pub use_jemalloc: bool,
     pub backtrace: bool, // support for RUST_BACKTRACE
-    pub wasm_syscall: bool,
 
     // misc
     pub low_priority: bool,
@@ -283,7 +282,6 @@ struct Rust {
     test_miri: Option<bool>,
     save_toolstates: Option<String>,
     codegen_backends: Option<Vec<String>>,
-    wasm_syscall: Option<bool>,
 }
 
 /// TOML representation of how each build target is configured.
@@ -465,7 +463,6 @@ impl Config {
             set(&mut config.rust_dist_src, rust.dist_src);
             set(&mut config.quiet_tests, rust.quiet_tests);
             set(&mut config.test_miri, rust.test_miri);
-            set(&mut config.wasm_syscall, rust.wasm_syscall);
             config.rustc_parallel_queries = rust.experimental_parallel_queries.unwrap_or(false);
             config.rustc_default_linker = rust.default_linker.clone();
             config.musl_root = rust.musl_root.clone().map(PathBuf::from);

src/bootstrap/dist.rs

@@ -435,9 +435,11 @@ impl Step for Rustc {
             }
 
             // Copy over the codegen backends
-            let backends_src = builder.sysroot_codegen_backends(compiler);
-            let backends_rel = backends_src.strip_prefix(&src).unwrap();
-            let backends_dst = image.join(&backends_rel);
+            let backends_src = builder.sysroot_libdir(compiler, host)
+                .join("codegen-backends");
+            let backends_dst = image.join("lib/rustlib")
+                .join(&*host)
+                .join("lib/codegen-backends");
             t!(fs::create_dir_all(&backends_dst));
             cp_r(&backends_src, &backends_dst);
 

src/bootstrap/lib.rs

@@ -423,9 +423,6 @@ impl Build {
         if self.config.profiler {
             features.push_str(" profiler");
         }
-        if self.config.wasm_syscall {
-            features.push_str(" wasm_syscall");
-        }
         features
     }
 

src/bootstrap/test.rs

@@ -1286,14 +1286,6 @@ impl Step for Crate {
             cargo.env(format!("CARGO_TARGET_{}_RUNNER", envify(&target)),
                       build.config.nodejs.as_ref().expect("nodejs not configured"));
         } else if target.starts_with("wasm32") {
-            // Warn about running tests without the `wasm_syscall` feature enabled.
-            // The javascript shim implements the syscall interface so that test
-            // output can be correctly reported.
-            if !build.config.wasm_syscall {
-                println!("Libstd was built without `wasm_syscall` feature enabled: \
-                          test output may not be visible.");
-            }
-
             // On the wasm32-unknown-unknown target we're using LTO which is
             // incompatible with `-C prefer-dynamic`, so disable that here
             cargo.env("RUSTC_NO_PREFER_DYNAMIC", "1");

src/doc/unstable-book/src/language-features/generators.md

@@ -139,11 +139,11 @@ closure-like semantics. Namely:
   types and such.
 
 * Traits like `Send` and `Sync` are automatically implemented for a `Generator`
-  depending on the captured variables of the environment. Unlike closures,
+  depending on the captured variables of the environment. Unlike closures though
   generators also depend on variables live across suspension points. This means
   that although the ambient environment may be `Send` or `Sync`, the generator
   itself may not be due to internal variables live across `yield` points being
-  not-`Send` or not-`Sync`. Note that generators, like closures, do
+  not-`Send` or not-`Sync`. Note, though, that generators, like closures, do
   not implement traits like `Copy` or `Clone` automatically.
 
 * Whenever a generator is dropped it will drop all captured environment
@@ -155,7 +155,7 @@ lifted at a future date, the design is ongoing!
 
 ### Generators as state machines
 
-In the compiler, generators are currently compiled as state machines. Each
+In the compiler generators are currently compiled as state machines. Each
 `yield` expression will correspond to a different state that stores all live
 variables over that suspension point. Resumption of a generator will dispatch on
 the current state and then execute internally until a `yield` is reached, at

src/etc/wasm32-shim.js

@@ -28,74 +28,12 @@ let m = new WebAssembly.Module(buffer);
 
 let memory = null;
 
-function viewstruct(data, fields) {
-  return new Uint32Array(memory.buffer).subarray(data/4, data/4 + fields);
-}
-
 function copystr(a, b) {
-  let view = new Uint8Array(memory.buffer).subarray(a, a + b);
-  return String.fromCharCode.apply(null, view);
-}
-
-function syscall_write([fd, ptr, len]) {
-  let s = copystr(ptr, len);
-  switch (fd) {
-    case 1: process.stdout.write(s); break;
-    case 2: process.stderr.write(s); break;
+  if (memory === null) {
+    return null
   }
-}
-
-function syscall_exit([code]) {
-  process.exit(code);
-}
-
-function syscall_args(params) {
-  let [ptr, len] = params;
-
-  // Calculate total required buffer size
-  let totalLen = -1;
-  for (let i = 2; i < process.argv.length; ++i) {
-    totalLen += Buffer.byteLength(process.argv[i]) + 1;
-  }
-  if (totalLen < 0) { totalLen = 0; }
-  params[2] = totalLen;
-
-  // If buffer is large enough, copy data
-  if (len >= totalLen) {
-    let view = new Uint8Array(memory.buffer);
-    for (let i = 2; i < process.argv.length; ++i) {
-      let value = process.argv[i];
-      Buffer.from(value).copy(view, ptr);
-      ptr += Buffer.byteLength(process.argv[i]) + 1;
-    }
-  }
-}
-
-function syscall_getenv(params) {
-  let [keyPtr, keyLen, valuePtr, valueLen] = params;
-
-  let key = copystr(keyPtr, keyLen);
-  let value = process.env[key];
-
-  if (value == null) {
-    params[4] = 0xFFFFFFFF;
-  } else {
-    let view = new Uint8Array(memory.buffer);
-    let totalLen = Buffer.byteLength(value);
-    params[4] = totalLen;
-    if (valueLen >= totalLen) {
-      Buffer.from(value).copy(view, valuePtr);
-    }
-  }
-}
-
-function syscall_time(params) {
-  let t = Date.now();
-  let secs = Math.floor(t / 1000);
-  let millis = t % 1000;
-  params[1] = Math.floor(secs / 0x100000000);
-  params[2] = secs % 0x100000000;
-  params[3] = Math.floor(millis * 1000000);
+  let view = new Uint8Array(memory.buffer).slice(a, a + b);
+  return String.fromCharCode.apply(null, view);
 }
 
 let imports = {};
@@ -110,25 +48,68 @@ imports.env = {
   log10: Math.log10,
   log10f: Math.log10,
 
-  rust_wasm_syscall: function(index, data) {
-    switch (index) {
-      case 1: syscall_write(viewstruct(data, 3)); return true;
-      case 2: syscall_exit(viewstruct(data, 1)); return true;
-      case 3: syscall_args(viewstruct(data, 3)); return true;
-      case 4: syscall_getenv(viewstruct(data, 5)); return true;
-      case 6: syscall_time(viewstruct(data, 4)); return true;
-      default:
-        console.log("Unsupported syscall: " + index);
-        return false;
+  // These are called in src/libstd/sys/wasm/stdio.rs and are used when
+  // debugging is enabled.
+  rust_wasm_write_stdout: function(a, b) {
+    let s = copystr(a, b);
+    if (s !== null) {
+      process.stdout.write(s);
     }
-  }
+  },
+  rust_wasm_write_stderr: function(a, b) {
+    let s = copystr(a, b);
+    if (s !== null) {
+      process.stderr.write(s);
+    }
+  },
+
+  // These are called in src/libstd/sys/wasm/args.rs and are used when
+  // debugging is enabled.
+  rust_wasm_args_count: function() {
+    if (memory === null)
+      return 0;
+    return process.argv.length - 2;
+  },
+  rust_wasm_args_arg_size: function(i) {
+    return Buffer.byteLength(process.argv[i + 2]);
+  },
+  rust_wasm_args_arg_fill: function(idx, ptr) {
+    let arg = process.argv[idx + 2];
+    let view = new Uint8Array(memory.buffer);
+    Buffer.from(arg).copy(view, ptr);
+  },
+
+  // These are called in src/libstd/sys/wasm/os.rs and are used when
+  // debugging is enabled.
+  rust_wasm_getenv_len: function(a, b) {
+    let key = copystr(a, b);
+    if (key === null) {
+      return -1;
+    }
+    if (!(key in process.env)) {
+      return -1;
+    }
+    return Buffer.byteLength(process.env[key]);
+  },
+  rust_wasm_getenv_data: function(a, b, ptr) {
+    let key = copystr(a, b);
+    let value = process.env[key];
+    let view = new Uint8Array(memory.buffer);
+    Buffer.from(value).copy(view, ptr);
+  },
 };
 
-let instance = new WebAssembly.Instance(m, imports);
-memory = instance.exports.memory;
-try {
-  instance.exports.main();
-} catch (e) {
-  console.error(e);
-  process.exit(101);
+let module_imports = WebAssembly.Module.imports(m);
+
+for (var i = 0; i < module_imports.length; i++) {
+  let imp = module_imports[i];
+  if (imp.module != 'env') {
+    continue
+  }
+  if (imp.name == 'memory' && imp.kind == 'memory') {
+    memory = new WebAssembly.Memory({initial: 20});
+    imports.env.memory = memory;
+  }
 }
+
+let instance = new WebAssembly.Instance(m, imports);

src/liballoc/btree/map.rs

@@ -1748,11 +1748,6 @@ impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
 {
     type Output = V;
 
-    /// Returns a reference to the value corresponding to the supplied key.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the key is not present in the `BTreeMap`.
     #[inline]
     fn index(&self, key: &Q) -> &V {
         self.get(key).expect("no entry found for key")

src/libcore/fmt/mod.rs

@@ -1586,7 +1586,6 @@ impl Display for ! {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for bool {
-    #[inline]
     fn fmt(&self, f: &mut Formatter) -> Result {
         Display::fmt(self, f)
     }
@@ -1749,7 +1748,6 @@ impl<T: Debug> Debug for [T] {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for () {
-    #[inline]
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.pad("()")
     }

src/libcore/fmt/num.rs

@@ -157,7 +157,6 @@ macro_rules! debug {
     ($T:ident) => {
         #[stable(feature = "rust1", since = "1.0.0")]
         impl fmt::Debug for $T {
-            #[inline]
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 fmt::Display::fmt(self, f)
             }

src/libcore/iter/mod.rs

@@ -307,7 +307,6 @@ use fmt;
 use iter_private::TrustedRandomAccess;
 use ops::Try;
 use usize;
-use intrinsics;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::iterator::Iterator;
@@ -695,49 +694,6 @@ impl<I> Iterator for StepBy<I> where I: Iterator {
             (f(inner_hint.0), inner_hint.1.map(f))
         }
     }
-
-    #[inline]
-    fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
-        if self.first_take {
-            self.first_take = false;
-            let first = self.iter.next();
-            if n == 0 {
-                return first;
-            }
-            n -= 1;
-        }
-        // n and self.step are indices, we need to add 1 to get the amount of elements
-        // When calling `.nth`, we need to subtract 1 again to convert back to an index
-        // step + 1 can't overflow because `.step_by` sets `self.step` to `step - 1`
-        let mut step = self.step + 1;
-        // n + 1 could overflow
-        // thus, if n is usize::MAX, instead of adding one, we call .nth(step)
-        if n == usize::MAX {
-            self.iter.nth(step - 1);
-        } else {
-            n += 1;
-        }
-
-        // overflow handling
-        loop {
-            let mul = n.checked_mul(step);
-            if unsafe { intrinsics::likely(mul.is_some()) } {
-                return self.iter.nth(mul.unwrap() - 1);
-            }
-            let div_n = usize::MAX / n;
-            let div_step = usize::MAX / step;
-            let nth_n = div_n * n;
-            let nth_step = div_step * step;
-            let nth = if nth_n > nth_step {
-                step -= div_n;
-                nth_n
-            } else {
-                n -= div_step;
-                nth_step
-            };
-            self.iter.nth(nth - 1);
-        }
-    }
 }
 
 // StepBy can only make the iterator shorter, so the len will still fit.