rust-lang
diff --git a/‎src/cargo/core/workspace.rs
+3-4 b/‎src/cargo/core/workspace.rs
+3-4
diff --git a/‎src/cargo/ops/cargo_read_manifest.rs
+2-15 b/‎src/cargo/ops/cargo_read_manifest.rs
+2-15
diff --git a/‎src/cargo/ops/mod.rs
+1-1 b/‎src/cargo/ops/mod.rs
+1-1
diff --git a/‎src/cargo/util/paths.rs
+3-3 b/‎src/cargo/util/paths.rs
+3-3
@@ -7,10 +7,10 @@ use glob::glob;
 
 use core::{Package, VirtualManifest, EitherManifest, SourceId};
 use core::{PackageIdSpec, Dependency, Profile, Profiles};
-use ops;
 use util::{Config, Filesystem};
 use util::errors::{CargoResult, CargoResultExt};
 use util::paths;
+use util::toml::read_manifest;
 
 /// The core abstraction in Cargo for working with a workspace of crates.
 ///
@@ -594,9 +594,8 @@ impl<'cfg> Packages<'cfg> {
             Entry::Occupied(e) => Ok(e.into_mut()),
             Entry::Vacant(v) => {
                 let source_id = SourceId::for_path(key)?;
-                let pair = ops::read_manifest(&manifest_path, &source_id,
-                                              self.config)?;
-                let (manifest, _nested_paths) = pair;
+                let (manifest, _nested_paths) =
+                    read_manifest(&manifest_path, &source_id, self.config)?;
                 Ok(v.insert(match manifest {
                     EitherManifest::Real(manifest) => {
                         MaybePackage::Package(Package::new(manifest,
 
@@ -4,23 +4,10 @@ use std::io;
 use std::path::{Path, PathBuf};
 
 use core::{Package, SourceId, PackageId, EitherManifest};
-use util::{self, paths, Config};
+use util::{self, Config};
 use util::errors::{CargoResult, CargoResultExt};
 use util::important_paths::find_project_manifest_exact;
-use util::toml::Layout;
-
-pub fn read_manifest(path: &Path, source_id: &SourceId, config: &Config)
-                     -> CargoResult<(EitherManifest, Vec<PathBuf>)> {
-    trace!("read_package; path={}; source-id={}", path.display(), source_id);
-    let contents = paths::read(path)?;
-
-    let layout = Layout::from_project_path(path.parent().unwrap());
-    let root = layout.root.clone();
-    util::toml::to_manifest(&contents, source_id, layout, config).chain_err(|| {
-        format!("failed to parse manifest at `{}`",
-                root.join("Cargo.toml").display())
-    })
-}
+use util::toml::read_manifest;
 
 pub fn read_package(path: &Path, source_id: &SourceId, config: &Config)
                     -> CargoResult<(Package, Vec<PathBuf>)> {
 
@@ -1,7 +1,7 @@
 pub use self::cargo_clean::{clean, CleanOptions};
 pub use self::cargo_compile::{compile, compile_with_exec, compile_ws, CompileOptions};
 pub use self::cargo_compile::{CompileFilter, CompileMode, MessageFormat, Packages};
-pub use self::cargo_read_manifest::{read_manifest,read_package,read_packages};
+pub use self::cargo_read_manifest::{read_package, read_packages};
 pub use self::cargo_rustc::{compile_targets, Compilation, Kind, Unit};
 pub use self::cargo_rustc::{Context, is_bad_artifact_name};
 pub use self::cargo_rustc::{BuildOutput, BuildConfig, TargetConfig};
 
@@ -54,9 +54,9 @@ pub fn normalize_path(path: &Path) -> PathBuf {
     ret
 }
 
-pub fn without_prefix<'a>(a: &'a Path, b: &'a Path) -> Option<&'a Path> {
-    let mut a = a.components();
-    let mut b = b.components();
+pub fn without_prefix<'a>(long_path: &'a Path, prefix: &'a Path) -> Option<&'a Path> {
+    let mut a = long_path.components();
+    let mut b = prefix.components();
     loop {
         match b.next() {
             Some(y) => match a.next() {