diff --git a/crates/cargo-test-support/src/lib.rs b/crates/cargo-test-support/src/lib.rs
index 57da10dd54b..99e94a4bdce 100644
--- a/crates/cargo-test-support/src/lib.rs
+++ b/crates/cargo-test-support/src/lib.rs
@@ -1609,6 +1609,19 @@ pub fn basic_lib_manifest(name: &str) -> String {
     )
 }
 
+pub fn basic_workspace_manifest(name: &str, workspace: &str) -> String {
+    format!(
+        r#"
+        [package]
+        name = "{}"
+        version = "0.1.0"
+        authors = []
+        workspace = "{}"
+    "#,
+        name, workspace
+    )
+}
+
 pub fn path2url<P: AsRef<Path>>(p: P) -> Url {
     Url::from_file_path(p).ok().unwrap()
 }
diff --git a/src/cargo/core/compiler/standard_lib.rs b/src/cargo/core/compiler/standard_lib.rs
index ed3dd77336c..b4b4108c980 100644
--- a/src/cargo/core/compiler/standard_lib.rs
+++ b/src/cargo/core/compiler/standard_lib.rs
@@ -11,6 +11,7 @@ use crate::util::errors::CargoResult;
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::path::PathBuf;
+use std::rc::Rc;
 
 /// Parse the `-Zbuild-std` flag.
 pub fn parse_unstable_flag(value: Option<&str>) -> Vec<String> {
@@ -60,17 +61,13 @@ pub fn resolve_std<'cfg>(
         String::from("library/alloc"),
         String::from("library/test"),
     ];
-    let ws_config = crate::core::WorkspaceConfig::Root(crate::core::WorkspaceRootConfig::new(
-        &src_path,
-        &Some(members),
-        /*default_members*/ &None,
-        /*exclude*/ &None,
-        /*custom_metadata*/ &None,
-    ));
+    let ws_config = crate::core::WorkspaceConfig::Root(
+        crate::core::WorkspaceRootConfig::from_members(&src_path, members),
+    );
     let virtual_manifest = crate::core::VirtualManifest::new(
         /*replace*/ Vec::new(),
         patch,
-        ws_config,
+        Rc::new(ws_config),
         /*profiles*/ None,
         crate::core::Features::default(),
         None,
diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
index dc69fbc08e3..d1bc9cf24b5 100644
--- a/src/cargo/core/manifest.rs
+++ b/src/cargo/core/manifest.rs
@@ -16,7 +16,7 @@ use crate::core::{Dependency, PackageId, PackageIdSpec, SourceId, Summary};
 use crate::core::{Edition, Feature, Features, WorkspaceConfig};
 use crate::util::errors::*;
 use crate::util::interning::InternedString;
-use crate::util::toml::{TomlManifest, TomlProfiles};
+use crate::util::toml::{DefinedTomlManifest, TomlProfiles};
 use crate::util::{short_hash, Config, Filesystem};
 
 pub enum EitherManifest {
@@ -24,6 +24,15 @@ pub enum EitherManifest {
     Virtual(VirtualManifest),
 }
 
+impl EitherManifest {
+    pub fn workspace(&self) -> Rc<WorkspaceConfig> {
+        match self {
+            Self::Real(manifest) => Rc::clone(&manifest.workspace),
+            Self::Virtual(virtual_manifest) => Rc::clone(&virtual_manifest.workspace),
+        }
+    }
+}
+
 /// Contains all the information about a package, as loaded from a `Cargo.toml`.
 #[derive(Clone, Debug)]
 pub struct Manifest {
@@ -40,8 +49,8 @@ pub struct Manifest {
     publish_lockfile: bool,
     replace: Vec<(PackageIdSpec, Dependency)>,
     patch: HashMap<Url, Vec<Dependency>>,
-    workspace: WorkspaceConfig,
-    original: Rc<TomlManifest>,
+    workspace: Rc<WorkspaceConfig>,
+    original: Rc<DefinedTomlManifest>,
     features: Features,
     edition: Edition,
     im_a_teapot: Option<bool>,
@@ -66,7 +75,7 @@ pub struct Warnings(Vec<DelayedWarning>);
 pub struct VirtualManifest {
     replace: Vec<(PackageIdSpec, Dependency)>,
     patch: HashMap<Url, Vec<Dependency>>,
-    workspace: WorkspaceConfig,
+    workspace: Rc<WorkspaceConfig>,
     profiles: Option<TomlProfiles>,
     warnings: Warnings,
     features: Features,
@@ -370,12 +379,12 @@ impl Manifest {
         publish_lockfile: bool,
         replace: Vec<(PackageIdSpec, Dependency)>,
         patch: HashMap<Url, Vec<Dependency>>,
-        workspace: WorkspaceConfig,
+        workspace: Rc<WorkspaceConfig>,
         features: Features,
         edition: Edition,
         im_a_teapot: Option<bool>,
         default_run: Option<String>,
-        original: Rc<TomlManifest>,
+        original: Rc<DefinedTomlManifest>,
         metabuild: Option<Vec<String>>,
         resolve_behavior: Option<ResolveBehavior>,
     ) -> Manifest {
@@ -453,7 +462,7 @@ impl Manifest {
     pub fn replace(&self) -> &[(PackageIdSpec, Dependency)] {
         &self.replace
     }
-    pub fn original(&self) -> &TomlManifest {
+    pub fn original(&self) -> &DefinedTomlManifest {
         &self.original
     }
     pub fn patch(&self) -> &HashMap<Url, Vec<Dependency>> {
@@ -463,8 +472,8 @@ impl Manifest {
         self.links.as_deref()
     }
 
-    pub fn workspace_config(&self) -> &WorkspaceConfig {
-        &self.workspace
+    pub fn workspace_config(&self) -> Rc<WorkspaceConfig> {
+        Rc::clone(&self.workspace)
     }
 
     pub fn features(&self) -> &Features {
@@ -538,7 +547,7 @@ impl VirtualManifest {
     pub fn new(
         replace: Vec<(PackageIdSpec, Dependency)>,
         patch: HashMap<Url, Vec<Dependency>>,
-        workspace: WorkspaceConfig,
+        workspace: Rc<WorkspaceConfig>,
         profiles: Option<TomlProfiles>,
         features: Features,
         resolve_behavior: Option<ResolveBehavior>,
@@ -562,8 +571,8 @@ impl VirtualManifest {
         &self.patch
     }
 
-    pub fn workspace_config(&self) -> &WorkspaceConfig {
-        &self.workspace
+    pub fn workspace_config(&self) -> Rc<WorkspaceConfig> {
+        Rc::clone(&self.workspace)
     }
 
     pub fn profiles(&self) -> Option<&TomlProfiles> {
diff --git a/src/cargo/core/mod.rs b/src/cargo/core/mod.rs
index 5abab1b9cd4..3a9eeebbb1f 100644
--- a/src/cargo/core/mod.rs
+++ b/src/cargo/core/mod.rs
@@ -28,4 +28,4 @@ pub mod resolver;
 pub mod shell;
 pub mod source;
 pub mod summary;
-mod workspace;
+pub mod workspace;
diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index 1f327d75409..43f1d3f38b8 100644
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -240,7 +240,9 @@ impl Package {
         let manifest = self
             .manifest()
             .original()
-            .prepare_for_publish(ws, self.root())?;
+            .prepare_for_publish(ws, self.manifest_path())?
+            .into_toml_manifest();
+
         let toml = toml::to_string(&manifest)?;
         Ok(format!("{}\n{}", MANIFEST_PREAMBLE, toml))
     }
diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
index a8f95fcddeb..b76e0485de9 100644
--- a/src/cargo/core/workspace.rs
+++ b/src/cargo/core/workspace.rs
@@ -20,7 +20,10 @@ use crate::sources::PathSource;
 use crate::util::errors::{CargoResult, CargoResultExt, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::paths;
-use crate::util::toml::{read_manifest, TomlProfiles};
+use crate::util::toml::{
+    parse_manifest, prepare_deps, read_manifest, DefinedTomlDependency, StringOrBool, TomlProfiles,
+    TomlWorkspace, VecStringOrBool,
+};
 use crate::util::{Config, Filesystem};
 
 /// The core abstraction in Cargo for working with a workspace of crates.
@@ -120,6 +123,15 @@ pub enum WorkspaceConfig {
     Member { root: Option<String> },
 }
 
+impl WorkspaceConfig {
+    pub fn is_root(&self) -> bool {
+        match self {
+            Self::Root(_) => true,
+            _ => false,
+        }
+    }
+}
+
 /// Intermediate configuration of a workspace root in a manifest.
 ///
 /// Knows the Workspace Root path, as well as `members` and `exclude` lists of path patterns, which
@@ -131,6 +143,23 @@ pub struct WorkspaceRootConfig {
     default_members: Option<Vec<String>>,
     exclude: Vec<String>,
     custom_metadata: Option<toml::Value>,
+
+    // Properties that can be inherited by members.
+    dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    version: Option<semver::Version>,
+    authors: Option<Vec<String>>,
+    description: Option<String>,
+    documentation: Option<String>,
+    readme: Option<StringOrBool>,
+    homepage: Option<String>,
+    repository: Option<String>,
+    license: Option<String>,
+    license_file: Option<String>,
+    keywords: Option<Vec<String>>,
+    categories: Option<Vec<String>>,
+    publish: Option<VecStringOrBool>,
+    edition: Option<String>,
+    badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
 }
 
 /// An iterator over the member packages of a workspace, returned by
@@ -157,9 +186,10 @@ impl<'cfg> Workspace<'cfg> {
                 manifest_path
             )
         } else {
-            ws.root_manifest = ws.find_root(manifest_path)?;
+            ws.root_manifest = find_workspace_root(manifest_path, config)?;
         }
 
+        ws.load_current()?;
         ws.custom_metadata = ws
             .load_workspace_config()?
             .and_then(|cfg| cfg.custom_metadata);
@@ -247,6 +277,11 @@ impl<'cfg> Workspace<'cfg> {
         Ok(ws)
     }
 
+    fn load_current(&mut self) -> CargoResult<()> {
+        self.packages.load(&self.current_manifest)?;
+        Ok(())
+    }
+
     /// Returns the current package of this workspace.
     ///
     /// Note that this can return an error if it the current manifest is
@@ -413,7 +448,7 @@ impl<'cfg> Workspace<'cfg> {
         // metadata.
         if let Some(root_path) = &self.root_manifest {
             let root_package = self.packages.load(root_path)?;
-            match root_package.workspace_config() {
+            match root_package.workspace_config().as_ref() {
                 WorkspaceConfig::Root(ref root_config) => {
                     return Ok(Some(root_config.clone()));
                 }
@@ -428,79 +463,6 @@ impl<'cfg> Workspace<'cfg> {
         Ok(None)
     }
 
-    /// Finds the root of a workspace for the crate whose manifest is located
-    /// at `manifest_path`.
-    ///
-    /// This will parse the `Cargo.toml` at `manifest_path` and then interpret
-    /// the workspace configuration, optionally walking up the filesystem
-    /// looking for other workspace roots.
-    ///
-    /// Returns an error if `manifest_path` isn't actually a valid manifest or
-    /// if some other transient error happens.
-    fn find_root(&mut self, manifest_path: &Path) -> CargoResult<Option<PathBuf>> {
-        fn read_root_pointer(member_manifest: &Path, root_link: &str) -> CargoResult<PathBuf> {
-            let path = member_manifest
-                .parent()
-                .unwrap()
-                .join(root_link)
-                .join("Cargo.toml");
-            debug!("find_root - pointer {}", path.display());
-            Ok(paths::normalize_path(&path))
-        };
-
-        {
-            let current = self.packages.load(manifest_path)?;
-            match *current.workspace_config() {
-                WorkspaceConfig::Root(_) => {
-                    debug!("find_root - is root {}", manifest_path.display());
-                    return Ok(Some(manifest_path.to_path_buf()));
-                }
-                WorkspaceConfig::Member {
-                    root: Some(ref path_to_root),
-                } => return Ok(Some(read_root_pointer(manifest_path, path_to_root)?)),
-                WorkspaceConfig::Member { root: None } => {}
-            }
-        }
-
-        for path in paths::ancestors(manifest_path).skip(2) {
-            if path.ends_with("target/package") {
-                break;
-            }
-
-            let ances_manifest_path = path.join("Cargo.toml");
-            debug!("find_root - trying {}", ances_manifest_path.display());
-            if ances_manifest_path.exists() {
-                match *self.packages.load(&ances_manifest_path)?.workspace_config() {
-                    WorkspaceConfig::Root(ref ances_root_config) => {
-                        debug!("find_root - found a root checking exclusion");
-                        if !ances_root_config.is_excluded(manifest_path) {
-                            debug!("find_root - found!");
-                            return Ok(Some(ances_manifest_path));
-                        }
-                    }
-                    WorkspaceConfig::Member {
-                        root: Some(ref path_to_root),
-                    } => {
-                        debug!("find_root - found pointer");
-                        return Ok(Some(read_root_pointer(&ances_manifest_path, path_to_root)?));
-                    }
-                    WorkspaceConfig::Member { .. } => {}
-                }
-            }
-
-            // Don't walk across `CARGO_HOME` when we're looking for the
-            // workspace root. Sometimes a package will be organized with
-            // `CARGO_HOME` pointing inside of the workspace root or in the
-            // current package, but we don't want to mistakenly try to put
-            // crates.io crates into the workspace by accident.
-            if self.config.home() == path {
-                break;
-            }
-        }
-
-        Ok(None)
-    }
-
     /// After the root of a workspace has been located, probes for all members
     /// of a workspace.
     ///
@@ -587,7 +549,7 @@ impl<'cfg> Workspace<'cfg> {
         }
         if is_path_dep
             && !manifest_path.parent().unwrap().starts_with(self.root())
-            && self.find_root(&manifest_path)? != self.root_manifest
+            && find_workspace_root(&manifest_path, self.config)? != self.root_manifest
         {
             // If `manifest_path` is a path dependency outside of the workspace,
             // don't add it, or any of its dependencies, as a members.
@@ -691,7 +653,7 @@ impl<'cfg> Workspace<'cfg> {
             .iter()
             .filter(|&member| {
                 let config = self.packages.get(member).workspace_config();
-                matches!(config, WorkspaceConfig::Root(_))
+                matches!(config.as_ref(), WorkspaceConfig::Root(_))
             })
             .map(|member| member.parent().unwrap().to_path_buf())
             .collect();
@@ -720,7 +682,7 @@ impl<'cfg> Workspace<'cfg> {
 
     fn validate_members(&mut self) -> CargoResult<()> {
         for member in self.members.clone() {
-            let root = self.find_root(&member)?;
+            let root = find_workspace_root(&member, self.config)?;
             if root == self.root_manifest {
                 continue;
             }
@@ -1106,11 +1068,11 @@ impl<'cfg> Packages<'cfg> {
     }
 
     fn load(&mut self, manifest_path: &Path) -> CargoResult<&MaybePackage> {
-        let key = manifest_path.parent().unwrap();
-        match self.packages.entry(key.to_path_buf()) {
+        let key = manifest_path.parent().unwrap().to_path_buf();
+        match self.packages.entry(key.clone()) {
             Entry::Occupied(e) => Ok(e.into_mut()),
             Entry::Vacant(v) => {
-                let source_id = SourceId::for_path(key)?;
+                let source_id = SourceId::for_path(&key)?;
                 let (manifest, _nested_paths) =
                     read_manifest(manifest_path, source_id, self.config)?;
                 Ok(v.insert(match manifest {
@@ -1145,7 +1107,7 @@ impl<'a, 'cfg> Iterator for Members<'a, 'cfg> {
 }
 
 impl MaybePackage {
-    fn workspace_config(&self) -> &WorkspaceConfig {
+    fn workspace_config(&self) -> Rc<WorkspaceConfig> {
         match *self {
             MaybePackage::Package(ref p) => p.manifest().workspace_config(),
             MaybePackage::Virtual(ref vm) => vm.workspace_config(),
@@ -1154,22 +1116,65 @@ impl MaybePackage {
 }
 
 impl WorkspaceRootConfig {
-    /// Creates a new Intermediate Workspace Root configuration.
-    pub fn new(
-        root_dir: &Path,
-        members: &Option<Vec<String>>,
-        default_members: &Option<Vec<String>>,
-        exclude: &Option<Vec<String>>,
-        custom_metadata: &Option<toml::Value>,
-    ) -> WorkspaceRootConfig {
-        WorkspaceRootConfig {
+    pub fn from_members(root_dir: &Path, members: Vec<String>) -> WorkspaceRootConfig {
+        Self {
             root_dir: root_dir.to_path_buf(),
-            members: members.clone(),
-            default_members: default_members.clone(),
-            exclude: exclude.clone().unwrap_or_default(),
-            custom_metadata: custom_metadata.clone(),
+            members: Some(members),
+            default_members: None,
+            exclude: Vec::new(),
+            custom_metadata: None,
+            dependencies: None,
+            version: None,
+            authors: None,
+            description: None,
+            documentation: None,
+            readme: None,
+            homepage: None,
+            repository: None,
+            license: None,
+            license_file: None,
+            keywords: None,
+            categories: None,
+            publish: None,
+            edition: None,
+            badges: None,
         }
     }
+    /// Creates a new Intermediate Workspace Root configuration from a toml workspace.
+    pub fn from_toml_workspace(
+        root_dir: &Path,
+        config: &Config,
+        toml_workspace: &TomlWorkspace,
+    ) -> CargoResult<Self> {
+        let dependencies = prepare_deps(
+            config,
+            toml_workspace.dependencies.as_ref(),
+            |_d: &DefinedTomlDependency| true,
+        )?;
+
+        Ok(Self {
+            root_dir: root_dir.to_path_buf(),
+            members: toml_workspace.members.clone(),
+            default_members: toml_workspace.default_members.clone(),
+            exclude: toml_workspace.exclude.clone().unwrap_or_default(),
+            custom_metadata: toml_workspace.metadata.clone(),
+            dependencies,
+            version: toml_workspace.version.clone(),
+            authors: toml_workspace.authors.clone(),
+            description: toml_workspace.description.clone(),
+            documentation: toml_workspace.documentation.clone(),
+            readme: toml_workspace.readme.clone(),
+            homepage: toml_workspace.homepage.clone(),
+            repository: toml_workspace.repository.clone(),
+            license: toml_workspace.license.clone(),
+            license_file: toml_workspace.license_file.clone(),
+            keywords: toml_workspace.keywords.clone(),
+            categories: toml_workspace.categories.clone(),
+            publish: toml_workspace.publish.clone(),
+            edition: toml_workspace.edition.clone(),
+            badges: toml_workspace.badges.clone(),
+        })
+    }
 
     /// Checks the path against the `excluded` list.
     ///
@@ -1237,3 +1242,85 @@ impl WorkspaceRootConfig {
         Ok(res)
     }
 }
+
+/// Finds the root of a workspace for the crate whose manifest is located
+/// at `manifest_path`.
+///
+/// This will parse the `Cargo.toml` at `manifest_path` and then interpret
+/// the workspace configuration, optionally walking up the filesystem
+/// looking for other workspace roots.
+///
+/// Returns an error if `manifest_path` isn't actually a valid manifest or
+/// if some other transient error happens.
+pub fn find_workspace_root(manifest_path: &Path, config: &Config) -> CargoResult<Option<PathBuf>> {
+    fn read_root_pointer(member_manifest: &Path, root_link: &str) -> CargoResult<PathBuf> {
+        let path = member_manifest
+            .parent()
+            .unwrap()
+            .join(root_link)
+            .join("Cargo.toml");
+        debug!("find_workspace_root - pointer {}", path.display());
+        Ok(paths::normalize_path(&path))
+    };
+
+    fn workspace_config(manifest_path: &Path, config: &Config) -> CargoResult<WorkspaceConfig> {
+        let output = parse_manifest(manifest_path, config)?;
+        output
+            .manifest
+            .workspace_config(manifest_path.parent().unwrap(), config)
+    }
+
+    {
+        match workspace_config(manifest_path, config)? {
+            WorkspaceConfig::Root(_) => {
+                debug!("find_workspace_root - is root {}", manifest_path.display());
+                return Ok(Some(manifest_path.to_path_buf()));
+            }
+            WorkspaceConfig::Member {
+                root: Some(ref path_to_root),
+            } => return Ok(Some(read_root_pointer(manifest_path, path_to_root)?)),
+            WorkspaceConfig::Member { root: None } => {}
+        }
+    }
+
+    for path in paths::ancestors(manifest_path).skip(2) {
+        if path.ends_with("target/package") {
+            break;
+        }
+
+        let ances_manifest_path = path.join("Cargo.toml");
+        debug!(
+            "find_workspace_root - trying {}",
+            ances_manifest_path.display()
+        );
+        if ances_manifest_path.exists() {
+            match workspace_config(&ances_manifest_path, config)? {
+                WorkspaceConfig::Root(ref ances_root_config) => {
+                    debug!("find_workspace_root - found a root checking exclusion");
+                    if !ances_root_config.is_excluded(manifest_path) {
+                        debug!("find_workspace_root - found!");
+                        return Ok(Some(ances_manifest_path));
+                    }
+                }
+                WorkspaceConfig::Member {
+                    root: Some(ref path_to_root),
+                } => {
+                    debug!("find_workspace_root - found pointer");
+                    return Ok(Some(read_root_pointer(&ances_manifest_path, path_to_root)?));
+                }
+                WorkspaceConfig::Member { .. } => {}
+            }
+        }
+
+        // Don't walk across `CARGO_HOME` when we're looking for the
+        // workspace root. Sometimes a package will be organized with
+        // `CARGO_HOME` pointing inside of the workspace root or in the
+        // current package, but we don't want to mistakenly try to put
+        // crates.io crates into the workspace by accident.
+        if config.home() == path {
+            break;
+        }
+    }
+
+    Ok(None)
+}
diff --git a/src/cargo/ops/cargo_package.rs b/src/cargo/ops/cargo_package.rs
index 5dc077c4b4d..356d652176c 100644
--- a/src/cargo/ops/cargo_package.rs
+++ b/src/cargo/ops/cargo_package.rs
@@ -3,7 +3,6 @@ use std::fs::{self, File};
 use std::io::prelude::*;
 use std::io::SeekFrom;
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
 use std::sync::Arc;
 use std::time::SystemTime;
 
@@ -18,7 +17,6 @@ use crate::core::{Package, PackageId, PackageSet, Resolve, Source, SourceId};
 use crate::sources::PathSource;
 use crate::util::errors::{CargoResult, CargoResultExt};
 use crate::util::paths;
-use crate::util::toml::TomlManifest;
 use crate::util::{self, restricted_names, Config, FileLock};
 use crate::{drop_println, ops};
 
@@ -107,8 +105,6 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option
         return Ok(None);
     }
 
-    verify_dependencies(pkg)?;
-
     let filename = format!("{}-{}.crate", pkg.name(), pkg.version());
     let dir = ws.target_dir().join("package");
     let mut dst = {
@@ -270,16 +266,14 @@ fn build_lock(ws: &Workspace<'_>) -> CargoResult<String> {
 
     // Convert Package -> TomlManifest -> Manifest -> Package
     let orig_pkg = ws.current()?;
-    let toml_manifest = Rc::new(
-        orig_pkg
-            .manifest()
-            .original()
-            .prepare_for_publish(ws, orig_pkg.root())?,
-    );
-    let package_root = orig_pkg.root();
+    let manifest_path = orig_pkg.manifest_path();
+    let toml_manifest = orig_pkg
+        .manifest()
+        .original()
+        .prepare_for_publish(ws, manifest_path)?;
     let source_id = orig_pkg.package_id().source_id();
     let (manifest, _nested_paths) =
-        TomlManifest::to_real_manifest(&toml_manifest, source_id, package_root, config)?;
+        toml_manifest.into_real_manifest(source_id, manifest_path, config)?;
     let new_pkg = Package::new(manifest, orig_pkg.manifest_path());
 
     // Regenerate Cargo.lock using the old one as a guide.
@@ -335,21 +329,6 @@ fn check_metadata(pkg: &Package, config: &Config) -> CargoResult<()> {
     Ok(())
 }
 
-// Checks that the package dependencies are safe to deploy.
-fn verify_dependencies(pkg: &Package) -> CargoResult<()> {
-    for dep in pkg.dependencies() {
-        if dep.source_id().is_path() && !dep.specified_req() && dep.is_transitive() {
-            anyhow::bail!(
-                "all path dependencies must have a version specified \
-                 when packaging.\ndependency `{}` does not specify \
-                 a version.",
-                dep.name_in_toml()
-            )
-        }
-    }
-    Ok(())
-}
-
 /// Checks if the package source is in a *git* DVCS repository. If *git*, and
 /// the source is *dirty* (e.g., has uncommitted changes) then `bail!` with an
 /// informative message. Otherwise return the sha1 hash of the current *HEAD*
diff --git a/src/cargo/ops/registry.rs b/src/cargo/ops/registry.rs
index abdce2267e1..6bc211386bc 100644
--- a/src/cargo/ops/registry.rs
+++ b/src/cargo/ops/registry.rs
@@ -134,7 +134,7 @@ fn verify_dependencies(
     registry_src: SourceId,
 ) -> CargoResult<()> {
     for dep in pkg.dependencies().iter() {
-        if dep.source_id().is_path() || dep.source_id().is_git() {
+        if dep.source_id().is_git() {
             if !dep.specified_req() {
                 if !dep.is_transitive() {
                     // dev-dependencies will be stripped in TomlManifest::prepare_for_publish
@@ -161,7 +161,7 @@ fn verify_dependencies(
             }
         // TomlManifest::prepare_for_publish will rewrite the dependency
         // to be just the `version` field.
-        } else if dep.source_id() != registry_src {
+        } else if !dep.source_id().is_path() && dep.source_id() != registry_src {
             if !dep.source_id().is_registry() {
                 // Consider making SourceId::kind a public type that we can
                 // exhaustively match on. Using match can help ensure that
diff --git a/src/cargo/util/config/mod.rs b/src/cargo/util/config/mod.rs
index b3d1d7b5e86..964e2a86ca1 100644
--- a/src/cargo/util/config/mod.rs
+++ b/src/cargo/util/config/mod.rs
@@ -176,6 +176,8 @@ pub struct Config {
     build_config: LazyCell<CargoBuildConfig>,
     target_cfgs: LazyCell<Vec<(String, TargetCfgConfig)>>,
     doc_extern_map: LazyCell<RustdocExternMap>,
+    /// Cache parsed manifests to avoid parsing twice.
+    manifest_cache: LazyCell<RefCell<cargo_toml::ManifestCache>>,
 }
 
 impl Config {
@@ -247,6 +249,7 @@ impl Config {
             build_config: LazyCell::new(),
             target_cfgs: LazyCell::new(),
             doc_extern_map: LazyCell::new(),
+            manifest_cache: LazyCell::new(),
         }
     }
 
@@ -1208,6 +1211,12 @@ impl Config {
             .try_borrow_with(|| self.get::<RustdocExternMap>("doc.extern-map"))
     }
 
+    pub fn manifest_cache(&self) -> RefMut<'_, cargo_toml::ManifestCache> {
+        self.manifest_cache
+            .borrow_with(|| RefCell::new(cargo_toml::ManifestCache::new()))
+            .borrow_mut()
+    }
+
     /// Returns the `[target]` table definition for the given target triple.
     pub fn target_cfg_triple(&self, target: &str) -> CargoResult<TargetConfig> {
         target::load_target_triple(self, target)
diff --git a/src/cargo/util/toml/manifest_cache.rs b/src/cargo/util/toml/manifest_cache.rs
new file mode 100644
index 00000000000..b0deacc0968
--- /dev/null
+++ b/src/cargo/util/toml/manifest_cache.rs
@@ -0,0 +1,102 @@
+use std::collections::{
+    hash_map::{Entry, HashMap},
+    BTreeSet,
+};
+use std::path::{Path, PathBuf};
+use std::rc::Rc;
+
+use super::{parse, TomlManifest};
+use crate::util::errors::{CargoResult, CargoResultExt, ManifestError};
+use crate::util::toml::{TomlProject, TomlWorkspace};
+use crate::util::{paths, Config};
+
+pub type ManifestCache = HashMap<PathBuf, ParseOutput>;
+
+#[derive(Debug, Clone)]
+pub struct ParseOutput {
+    pub manifest: Rc<TomlManifest>,
+    pub unused: Rc<BTreeSet<String>>,
+}
+
+impl ParseOutput {
+    pub fn workspace(&self) -> Option<&TomlWorkspace> {
+        self.manifest.workspace.as_ref()
+    }
+
+    pub fn package(&self) -> Option<&TomlProject> {
+        self.manifest
+            .package
+            .as_deref()
+            .or(self.manifest.project.as_deref())
+    }
+}
+
+pub fn parse_manifest<'a>(
+    manifest_file: &'_ Path,
+    config: &'a Config,
+) -> Result<ParseOutput, ManifestError> {
+    let key = manifest_file.parent().unwrap().to_path_buf();
+    let mut cache = config.manifest_cache();
+
+    match cache.entry(key.clone()) {
+        Entry::Occupied(e) => Ok(e.get().clone()),
+        Entry::Vacant(v) => {
+            let contents = paths::read(manifest_file)
+                .map_err(|err| ManifestError::new(err, manifest_file.into()))?;
+
+            let output = deserialize(contents, manifest_file, config)
+                .chain_err(|| format!("failed to parse manifest at `{}`", manifest_file.display()))
+                .map_err(|err| ManifestError::new(err, manifest_file.into()))?;
+
+            Ok(v.insert(output).clone())
+        }
+    }
+}
+
+fn deserialize(
+    contents: String,
+    manifest_file: &Path,
+    config: &Config,
+) -> CargoResult<ParseOutput> {
+    let pretty_filename = manifest_file
+        .strip_prefix(config.cwd())
+        .unwrap_or(manifest_file);
+
+    let toml = parse(&contents, pretty_filename, config)?;
+    let mut unused = BTreeSet::new();
+    let manifest: TomlManifest = serde_ignored::deserialize(toml, |path| {
+        let mut key = String::new();
+        stringify(&mut key, &path);
+        unused.insert(key);
+    })?;
+
+    Ok(ParseOutput {
+        manifest: Rc::new(manifest),
+        unused: Rc::new(unused),
+    })
+}
+
+fn stringify(dst: &mut String, path: &serde_ignored::Path<'_>) {
+    use serde_ignored::Path;
+
+    match *path {
+        Path::Root => {}
+        Path::Seq { parent, index } => {
+            stringify(dst, parent);
+            if !dst.is_empty() {
+                dst.push('.');
+            }
+            dst.push_str(&index.to_string());
+        }
+        Path::Map { parent, ref key } => {
+            stringify(dst, parent);
+            if !dst.is_empty() {
+                dst.push('.');
+            }
+            dst.push_str(key);
+        }
+        Path::Some { parent }
+        | Path::NewtypeVariant { parent }
+        | Path::NewtypeStruct { parent } => stringify(dst, parent),
+    }
+}
diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
index 4bb1d7f4d2b..24374fa309a 100644
--- a/src/cargo/util/toml/mod.rs
+++ b/src/cargo/util/toml/mod.rs
@@ -1,5 +1,6 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt;
+use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::str;
@@ -8,7 +9,7 @@ use anyhow::{anyhow, bail};
 use cargo_platform::Platform;
 use log::{debug, trace};
 use semver::{self, VersionReq};
-use serde::de;
+use serde::de::{self, IntoDeserializer};
 use serde::ser;
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -17,6 +18,7 @@ use crate::core::dependency::DepKind;
 use crate::core::manifest::{ManifestMetadata, TargetSourcePath, Warnings};
 use crate::core::profiles::Strip;
 use crate::core::resolver::ResolveBehavior;
+use crate::core::workspace::find_workspace_root;
 use crate::core::{Dependency, Manifest, PackageId, Summary, Target};
 use crate::core::{Edition, EitherManifest, Feature, Features, VirtualManifest, Workspace};
 use crate::core::{GitReference, PackageIdSpec, SourceId, WorkspaceConfig, WorkspaceRootConfig};
@@ -27,6 +29,8 @@ use crate::util::{self, paths, validate_package_name, Config, IntoUrl};
 
 mod targets;
 use self::targets::targets;
+mod manifest_cache;
+pub use manifest_cache::{parse_manifest, ManifestCache, ParseOutput};
 
 pub fn read_manifest(
     path: &Path,
@@ -38,36 +42,28 @@ pub fn read_manifest(
         path.display(),
         source_id
     );
-    let contents = paths::read(path).map_err(|err| ManifestError::new(err, path.into()))?;
 
-    do_read_manifest(&contents, path, source_id, config)
+    let output = parse_manifest(path, config)?;
+
+    do_read_manifest(&output, path, source_id, config)
         .chain_err(|| format!("failed to parse manifest at `{}`", path.display()))
         .map_err(|err| ManifestError::new(err, path.into()))
 }
 
 fn do_read_manifest(
-    contents: &str,
+    output: &ParseOutput,
     manifest_file: &Path,
     source_id: SourceId,
     config: &Config,
 ) -> CargoResult<(EitherManifest, Vec<PathBuf>)> {
-    let package_root = manifest_file.parent().unwrap();
-
-    let toml = {
-        let pretty_filename = manifest_file
-            .strip_prefix(config.cwd())
-            .unwrap_or(manifest_file);
-        parse(contents, pretty_filename, config)?
-    };
+    let manifest = DefinedTomlManifest::from_toml_manifest(
+        TomlManifest::clone(&output.manifest),
+        manifest_file,
+        config,
+    )?;
 
-    let mut unused = BTreeSet::new();
-    let manifest: TomlManifest = serde_ignored::deserialize(toml, |path| {
-        let mut key = String::new();
-        stringify(&mut key, &path);
-        unused.insert(key);
-    })?;
     let add_unused = |warnings: &mut Warnings| {
-        for key in unused {
+        for key in output.unused.iter() {
             warnings.add_warning(format!("unused manifest key: {}", key));
             if key == "profiles.debug" {
                 warnings.add_warning("use `[profile.dev]` to configure debug builds".to_string());
@@ -75,10 +71,24 @@ fn do_read_manifest(
         }
     };
 
-    let manifest = Rc::new(manifest);
-    return if manifest.project.is_some() || manifest.package.is_some() {
+    if let Some(deps) = manifest
+        .workspace
+        .as_ref()
+        .and_then(|ws| ws.dependencies.as_ref())
+    {
+        for (name, dep) in deps {
+            if dep.is_optional() {
+                bail!(
+                    "{} is optional, but workspace dependencies cannot be optional",
+                    name
+                );
+            }
+        }
+    }
+
+    return if manifest.package.is_some() {
         let (mut manifest, paths) =
-            TomlManifest::to_real_manifest(&manifest, source_id, package_root, config)?;
+            manifest.into_real_manifest(source_id, manifest_file, config)?;
         add_unused(manifest.warnings_mut());
         if manifest.targets().iter().all(|t| t.is_custom_build()) {
             bail!(
@@ -89,36 +99,10 @@ fn do_read_manifest(
         }
         Ok((EitherManifest::Real(manifest), paths))
     } else {
-        let (mut m, paths) =
-            TomlManifest::to_virtual_manifest(&manifest, source_id, package_root, config)?;
+        let (mut m, paths) = manifest.into_virtual_manifest(source_id, manifest_file, config)?;
         add_unused(m.warnings_mut());
         Ok((EitherManifest::Virtual(m), paths))
     };
-
-    fn stringify(dst: &mut String, path: &serde_ignored::Path<'_>) {
-        use serde_ignored::Path;
-
-        match *path {
-            Path::Root => {}
-            Path::Seq { parent, index } => {
-                stringify(dst, parent);
-                if !dst.is_empty() {
-                    dst.push('.');
-                }
-                dst.push_str(&index.to_string());
-            }
-            Path::Map { parent, ref key } => {
-                stringify(dst, parent);
-                if !dst.is_empty() {
-                    dst.push('.');
-                }
-                dst.push_str(key);
-            }
-            Path::Some { parent }
-            | Path::NewtypeVariant { parent }
-            | Path::NewtypeStruct { parent } => stringify(dst, parent),
-        }
-    }
 }
 
 pub fn parse(toml: &str, file: &Path, config: &Config) -> CargoResult<toml::Value> {
@@ -173,13 +157,69 @@ type TomlExampleTarget = TomlTarget;
 type TomlTestTarget = TomlTarget;
 type TomlBenchTarget = TomlTarget;
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(untagged, try_from = "TomlDependency")]
+pub enum DefinedTomlDependency {
+    Simple(String),
+    Detailed(TomlDependencyDetails),
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[serde(untagged)]
 pub enum TomlDependency {
     Simple(String),
-    Detailed(DetailedTomlDependency),
+    Workspace(WorkspaceDetails),
+    Detailed(TomlDependencyDetails),
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(into = "TomlWorkspaceDetails")]
+pub struct WorkspaceDetails {
+    features: Option<Vec<String>>,
+    optional: Option<bool>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct TomlWorkspaceDetails {
+    workspace: bool,
+    features: Option<Vec<String>>,
+    optional: Option<bool>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum DefinedTomlDependencyWrapper {
+    Simple(String),
+    Workspace(TomlWorkspaceDetails),
+    Detailed(TomlDependencyDetails),
 }
 
+impl From<WorkspaceDetails> for TomlWorkspaceDetails {
+    fn from(workspace_details: WorkspaceDetails) -> Self {
+        Self {
+            workspace: true,
+            features: workspace_details.features,
+            optional: workspace_details.optional,
+        }
+    }
+}
+
+impl std::convert::TryFrom<TomlDependency> for DefinedTomlDependency {
+    type Error = anyhow::Error;
+
+    fn try_from(toml_workspace_dependency: TomlDependency) -> CargoResult<Self> {
+        match toml_workspace_dependency {
+            TomlDependency::Simple(simple) => Ok(Self::Simple(simple)),
+            TomlDependency::Detailed(details) => Ok(Self::Detailed(details)),
+            TomlDependency::Workspace(_) => Err(anyhow!("cannot specify workspace dependency")),
+        }
+    }
+}
+
+// This implementation of `Deserialize`, along with many others in this file, exist entirely to
+// provide error handling. The error message in derived implementations of `Deserialize` are
+// sometimes too opaque to expose to end users. These implementations should otherwise behave
+// exactly like their derived counterparts.
 impl<'de> de::Deserialize<'de> for TomlDependency {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -201,7 +241,7 @@ impl<'de> de::Deserialize<'de> for TomlDependency {
             where
                 E: de::Error,
             {
-                Ok(TomlDependency::Simple(s.to_owned()))
+                Ok(Self::Value::Simple(s.to_owned()))
             }
 
             fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
@@ -209,7 +249,25 @@ impl<'de> de::Deserialize<'de> for TomlDependency {
                 V: de::MapAccess<'de>,
             {
                 let mvd = de::value::MapAccessDeserializer::new(map);
-                DetailedTomlDependency::deserialize(mvd).map(TomlDependency::Detailed)
+
+                Ok(match DefinedTomlDependencyWrapper::deserialize(mvd) {
+                    Ok(DefinedTomlDependencyWrapper::Simple(version)) => Self::Value::Simple(version),
+                    Ok(DefinedTomlDependencyWrapper::Detailed(details)) => Self::Value::Detailed(details),
+                    Ok(DefinedTomlDependencyWrapper::Workspace(ws)) if ws.workspace => {
+                        Self::Value::Workspace(WorkspaceDetails {
+                            features: ws.features,
+                            optional: ws.optional,
+                        })
+                    }
+
+                    Ok(DefinedTomlDependencyWrapper::Workspace(_)) => {
+                        return Err(de::Error::custom("workspace cannot be false"));
+                    }
+
+                    Err(_) => return Err(de::Error::custom(
+                        "a version string like \"0.9.8\" or a detailed dependency like { version = \"0.9.8\" }",
+                    )),
+                })
             }
         }
 
@@ -219,7 +277,7 @@ impl<'de> de::Deserialize<'de> for TomlDependency {
 
 #[derive(Deserialize, Serialize, Clone, Debug, Default)]
 #[serde(rename_all = "kebab-case")]
-pub struct DetailedTomlDependency {
+pub struct TomlDependencyDetails {
     version: Option<String>,
     registry: Option<String>,
     /// The URL of the `registry` field.
@@ -243,7 +301,7 @@ pub struct DetailedTomlDependency {
     public: Option<bool>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct TomlManifest {
     cargo_features: Option<Vec<String>>,
@@ -264,12 +322,242 @@ pub struct TomlManifest {
     build_dependencies2: Option<BTreeMap<String, TomlDependency>>,
     features: Option<BTreeMap<String, Vec<String>>>,
     target: Option<BTreeMap<String, TomlPlatform>>,
-    replace: Option<BTreeMap<String, TomlDependency>>,
-    patch: Option<BTreeMap<String, BTreeMap<String, TomlDependency>>>,
+    replace: Option<BTreeMap<String, DefinedTomlDependency>>,
+    patch: Option<BTreeMap<String, BTreeMap<String, DefinedTomlDependency>>>,
+    workspace: Option<TomlWorkspace>,
+    #[serde(deserialize_with = "deserialize_workspace_badges", default)]
+    badges: Option<MaybeWorkspace<BTreeMap<String, BTreeMap<String, String>>>>,
+}
+
+impl TomlManifest {
+    pub fn workspace_config(
+        &self,
+        package_root: &Path,
+        config: &Config,
+    ) -> CargoResult<WorkspaceConfig> {
+        let workspace = self.workspace.as_ref();
+        let project_workspace = self
+            .project
+            .as_ref()
+            .or_else(|| self.package.as_ref())
+            .and_then(|p| p.workspace.as_ref());
+
+        Ok(match (workspace, project_workspace) {
+            (Some(toml_workspace), None) => WorkspaceConfig::Root(
+                WorkspaceRootConfig::from_toml_workspace(package_root, &config, toml_workspace)?,
+            ),
+            (None, root) => WorkspaceConfig::Member {
+                root: root.cloned(),
+            },
+            (Some(..), Some(..)) => bail!(
+                "cannot configure both `package.workspace` and \
+                 `[workspace]`, only one can be specified"
+            ),
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DefinedTomlManifest {
+    cargo_features: Option<Vec<String>>,
+    package: Option<DefinedTomlPackage>,
+    profile: Option<TomlProfiles>,
+    lib: Option<TomlLibTarget>,
+    bin: Option<Vec<TomlBinTarget>>,
+    example: Option<Vec<TomlExampleTarget>>,
+    test: Option<Vec<TomlTestTarget>>,
+    bench: Option<Vec<TomlTestTarget>>,
+    dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    dev_dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    build_dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    features: Option<BTreeMap<String, Vec<String>>>,
+    target: Option<BTreeMap<String, DefinedTomlPlatform>>,
+    replace: Option<BTreeMap<String, DefinedTomlDependency>>,
+    patch: Option<BTreeMap<String, BTreeMap<String, DefinedTomlDependency>>>,
     workspace: Option<TomlWorkspace>,
     badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
 }
 
+struct WorkspaceContext<'a> {
+    config: &'a Config,
+    dependencies: &'a BTreeMap<String, DefinedTomlDependency>,
+    package_root: &'a Path,
+    root_path: Option<&'a Path>,
+}
+
+impl DefinedTomlManifest {
+    fn from_toml_manifest(
+        manifest: TomlManifest,
+        manifest_file: &Path,
+        config: &Config,
+    ) -> CargoResult<Self> {
+        let package_root = manifest_file.parent().unwrap();
+        let root_path = find_workspace_root(manifest_file, config)?;
+        let root_path = root_path.as_deref();
+
+        let output = root_path
+            .map(|root_path| parse_manifest(root_path, config))
+            .transpose()?;
+
+        let workspace = output.as_ref().and_then(|output| output.workspace());
+
+        let empty = BTreeMap::new();
+        let ctx = WorkspaceContext {
+            config,
+            dependencies: workspace
+                .map(|ws| ws.dependencies.as_ref())
+                .flatten()
+                .unwrap_or(&empty),
+            package_root,
+            root_path,
+        };
+
+        let package = manifest
+            .package
+            .or(manifest.project)
+            .map(|p| *p)
+            .map(|p| DefinedTomlPackage::from_toml_project(p, workspace, root_path, package_root))
+            .transpose()?;
+
+        let badges = ws_default(manifest.badges, workspace, |ws| &ws.badges, "badges")?;
+
+        let dependencies = to_defined_dependencies(manifest.dependencies.as_ref(), &ctx)?;
+        let dev_dependencies = to_defined_dependencies(
+            manifest
+                .dev_dependencies
+                .or(manifest.dev_dependencies2)
+                .as_ref(),
+            &ctx,
+        )?;
+
+        let build_dependencies = to_defined_dependencies(
+            manifest
+                .build_dependencies
+                .or(manifest.build_dependencies2)
+                .as_ref(),
+            &ctx,
+        )?;
+
+        let target = to_defined_platform(manifest.target, &ctx)?;
+
+        Ok(Self {
+            cargo_features: manifest.cargo_features,
+            package,
+            profile: manifest.profile,
+            lib: manifest.lib,
+            bin: manifest.bin,
+            example: manifest.example,
+            test: manifest.test,
+            bench: manifest.bench,
+            dependencies,
+            dev_dependencies,
+            build_dependencies,
+            features: manifest.features,
+            target,
+            replace: manifest.replace,
+            patch: manifest.patch,
+            workspace: manifest.workspace,
+            badges,
+        })
+    }
+}
+
+fn to_defined_dependencies(
+    dependencies: Option<&BTreeMap<String, TomlDependency>>,
+    ctx: &WorkspaceContext<'_>,
+) -> CargoResult<Option<BTreeMap<String, DefinedTomlDependency>>> {
+    map_btree(dependencies, |key, dep| {
+        DefinedTomlDependency::from_toml_dependency(dep, &key, ctx)
+            .chain_err(|| format!("failed to get dependency `{}`", key))
+    })
+}
+
+fn to_toml_dependencies(
+    dependencies: Option<&BTreeMap<String, DefinedTomlDependency>>,
+) -> Option<BTreeMap<String, TomlDependency>> {
+    map_btree(dependencies, |_key, dep| {
+        Ok(TomlDependency::from_defined_dependency(dep))
+    })
+    .unwrap()
+}
+
+fn to_defined_platform(
+    toml_platform: Option<BTreeMap<String, TomlPlatform>>,
+    ctx: &WorkspaceContext<'_>,
+) -> CargoResult<Option<BTreeMap<String, DefinedTomlPlatform>>> {
+    map_btree(toml_platform.as_ref(), |_key, toml_platform| {
+        DefinedTomlPlatform::from_toml_platform(toml_platform, ctx)
+    })
+}
+
+fn to_toml_platform(
+    defined_platform: Option<BTreeMap<String, DefinedTomlPlatform>>,
+) -> Option<BTreeMap<String, TomlPlatform>> {
+    map_btree(defined_platform.as_ref(), |_key, defined_platform| {
+        Ok(TomlPlatform::from_defined_platform(defined_platform))
+    })
+    .unwrap()
+}
+
+pub fn prepare_deps(
+    config: &Config,
+    deps: Option<&BTreeMap<String, DefinedTomlDependency>>,
+    filter: impl Fn(&DefinedTomlDependency) -> bool,
+) -> CargoResult<Option<BTreeMap<String, DefinedTomlDependency>>> {
+    let deps = match deps {
+        Some(deps) => deps,
+        None => return Ok(None),
+    };
+    let deps = deps
+        .iter()
+        .filter(|(_k, v)| filter(v))
+        .map(|(k, v)| Ok((k.clone(), prepare_dep(config, v)?)))
+        .collect::<CargoResult<BTreeMap<_, _>>>()?;
+    Ok(Some(deps))
+}
+
+fn prepare_dep(config: &Config, dep: &DefinedTomlDependency) -> CargoResult<DefinedTomlDependency> {
+    match dep {
+        DefinedTomlDependency::Detailed(d) => {
+            let mut d = d.clone();
+            // Path dependencies become crates.io deps.
+            d.path.take();
+            // Same with git dependencies.
+            d.git.take();
+            d.branch.take();
+            d.tag.take();
+            d.rev.take();
+
+            // registry specifications are elaborated to the index URL
+            if let Some(registry) = d.registry.take() {
+                let src = SourceId::alt_registry(config, &registry)?;
+                d.registry_index = Some(src.url().to_string());
+            }
+            Ok(DefinedTomlDependency::Detailed(d))
+        }
+        DefinedTomlDependency::Simple(s) => {
+            Ok(DefinedTomlDependency::Detailed(TomlDependencyDetails {
+                version: Some(s.clone()),
+                ..Default::default()
+            }))
+        }
+    }
+}
+
+fn map_btree<T, R>(
+    tree: Option<&BTreeMap<String, T>>,
+    f: impl Fn(&str, &T) -> CargoResult<R>,
+) -> CargoResult<Option<BTreeMap<String, R>>> {
+    match tree {
+        None => Ok(None),
+        Some(deps) => Ok(Some(
+            deps.iter()
+                .map(|(key, val)| Ok((key.clone(), f(&*key, val)?)))
+                .collect::<CargoResult<BTreeMap<_, _>>>()?,
+        )),
+    }
+}
+
 #[derive(Deserialize, Serialize, Clone, Debug, Default)]
 pub struct TomlProfiles(BTreeMap<InternedString, TomlProfile>);
 
@@ -699,6 +987,16 @@ pub enum StringOrBool {
     Bool(bool),
 }
 
+impl StringOrBool {
+    fn string_or_default(&self, default_value: &str) -> Option<String> {
+        match self {
+            Self::String(value) => Some(String::from(value)),
+            Self::Bool(true) => Some(String::from(default_value)),
+            Self::Bool(false) => None,
+        }
+    }
+}
+
 impl<'de> de::Deserialize<'de> for StringOrBool {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -773,6 +1071,179 @@ impl<'de> de::Deserialize<'de> for VecStringOrBool {
     }
 }
 
+#[derive(Serialize, Clone, Debug)]
+#[serde(untagged)]
+pub enum MaybeWorkspace<T> {
+    Workspace,
+    Defined(T),
+}
+
+impl<'de, T> de::Deserialize<'de> for MaybeWorkspace<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        struct MaybeWorkspaceVisitor<T> {
+            marker: PhantomData<fn() -> MaybeWorkspace<T>>,
+        }
+
+        impl<'de, T> de::Visitor<'de> for MaybeWorkspaceVisitor<T>
+        where
+            T: de::Deserialize<'de>,
+        {
+            type Value = MaybeWorkspace<T>;
+
+            /// The `visit_foo` methods should cover all the possibilities, so we should in theory
+            /// never fallback to this error message.
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("{ workspace: true } or a valid value")
+            }
+
+            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                T::deserialize(v.into_deserializer()).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                T::deserialize(s.into_deserializer()).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_i64<E>(self, numeric: i64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                T::deserialize(numeric.into_deserializer()).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_f64<E>(self, numeric: f64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                T::deserialize(numeric.into_deserializer()).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_u64<E>(self, numeric: u64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                T::deserialize(numeric.into_deserializer()).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error>
+            where
+                V: de::SeqAccess<'de>,
+            {
+                let svd = de::value::SeqAccessDeserializer::new(seq);
+                T::deserialize(svd).map(MaybeWorkspace::Defined)
+            }
+
+            fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
+            where
+                V: de::MapAccess<'de>,
+            {
+                let mvd = de::value::MapAccessDeserializer::new(map);
+                TomlWorkspaceField::deserialize(mvd).and_then(|t| {
+                    if t.workspace {
+                        Ok(MaybeWorkspace::Workspace)
+                    } else {
+                        Err(de::Error::custom("workspace cannot be false"))
+                    }
+                })
+            }
+        }
+
+        deserializer.deserialize_any(MaybeWorkspaceVisitor {
+            marker: PhantomData,
+        })
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum MaybeWorkspaceBadge {
+    Workspace(TomlWorkspaceField),
+    Defined(BTreeMap<String, BTreeMap<String, String>>),
+}
+
+/// This exists only to provide a nicer error message.
+fn deserialize_workspace_badges<'de, D>(
+    deserializer: D,
+) -> Result<Option<MaybeWorkspace<BTreeMap<String, BTreeMap<String, String>>>>, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    match Option::deserialize(deserializer) {
+        Ok(None) => Ok(None),
+        Ok(Some(MaybeWorkspaceBadge::Defined(badges))) => Ok(Some(MaybeWorkspace::Defined(badges))),
+        Ok(Some(MaybeWorkspaceBadge::Workspace(ws))) if ws.workspace => {
+            Ok(Some(MaybeWorkspace::Workspace))
+        }
+        Ok(Some(MaybeWorkspaceBadge::Workspace(_))) => {
+            Err(de::Error::custom("workspace cannot be false"))
+        }
+
+        Err(_) => Err(de::Error::custom(
+            "expected a table of badges or { workspace = true }",
+        )),
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct TomlWorkspaceField {
+    workspace: bool,
+}
+
+impl<T> MaybeWorkspace<T>
+where
+    T: std::fmt::Debug + Clone,
+{
+    fn from_option(value: &Option<T>) -> Option<Self> {
+        match value {
+            Some(value) => Some(Self::Defined(value.clone())),
+            None => None,
+        }
+    }
+}
+
+/// Parses an optional field, defaulting to the workspace's value.
+fn ws_default<T, F>(
+    value: Option<MaybeWorkspace<T>>,
+    workspace: Option<&TomlWorkspace>,
+    f: F,
+    label: &str,
+) -> CargoResult<Option<T>>
+where
+    T: std::fmt::Debug + Clone,
+    F: FnOnce(&TomlWorkspace) -> &Option<T>,
+{
+    match (value, workspace) {
+        (None, _) => Ok(None),
+        (Some(MaybeWorkspace::Defined(value)), _) => Ok(Some(value)),
+        (Some(MaybeWorkspace::Workspace), Some(ws)) => f(ws)
+            .clone()
+            .ok_or_else(|| {
+                anyhow!(
+                    "error reading `{0}` from workspace root manifest's `[workspace.{0}]`",
+                    label
+                )
+            })
+            .map(|value| Some(value)),
+
+        (Some(MaybeWorkspace::Workspace), None) => Err(anyhow!(
+            "error reading {}: could not find workspace root",
+            label
+        )),
+    }
+}
+
 /// Represents the `package`/`project` sections of a `Cargo.toml`.
 ///
 /// Note that the order of the fields matters, since this is the order they
@@ -781,16 +1252,16 @@ impl<'de> de::Deserialize<'de> for VecStringOrBool {
 /// tables.
 #[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct TomlProject {
-    edition: Option<String>,
+    edition: Option<MaybeWorkspace<String>>,
     name: InternedString,
-    version: semver::Version,
-    authors: Option<Vec<String>>,
+    version: MaybeWorkspace<semver::Version>,
+    authors: Option<MaybeWorkspace<Vec<String>>>,
     build: Option<StringOrBool>,
     metabuild: Option<StringOrVec>,
     links: Option<String>,
     exclude: Option<Vec<String>>,
     include: Option<Vec<String>>,
-    publish: Option<VecStringOrBool>,
+    publish: Option<MaybeWorkspace<VecStringOrBool>>,
     #[serde(rename = "publish-lockfile")]
     publish_lockfile: Option<bool>,
     workspace: Option<String>,
@@ -805,35 +1276,181 @@ pub struct TomlProject {
     #[serde(rename = "default-run")]
     default_run: Option<String>,
 
+    // Package metadata.
+    description: Option<MaybeWorkspace<String>>,
+    homepage: Option<MaybeWorkspace<String>>,
+    documentation: Option<MaybeWorkspace<String>>,
+    readme: Option<MaybeWorkspace<StringOrBool>>,
+    keywords: Option<MaybeWorkspace<Vec<String>>>,
+    categories: Option<MaybeWorkspace<Vec<String>>>,
+    license: Option<MaybeWorkspace<String>>,
+    #[serde(rename = "license-file")]
+    license_file: Option<MaybeWorkspace<String>>,
+    repository: Option<MaybeWorkspace<String>>,
+    metadata: Option<toml::Value>,
+    resolver: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+struct DefinedTomlPackage {
+    edition: Option<String>,
+    name: InternedString,
+    version: semver::Version,
+    authors: Option<Vec<String>>,
+    build: Option<StringOrBool>,
+    metabuild: Option<StringOrVec>,
+    links: Option<String>,
+    exclude: Option<Vec<String>>,
+    include: Option<Vec<String>>,
+    publish: Option<VecStringOrBool>,
+    publish_lockfile: Option<bool>,
+    pub workspace: Option<String>,
+    im_a_teapot: Option<bool>,
+    autobins: Option<bool>,
+    autoexamples: Option<bool>,
+    autotests: Option<bool>,
+    autobenches: Option<bool>,
+    namespaced_features: Option<bool>,
+    default_run: Option<String>,
+
     // Package metadata.
     description: Option<String>,
     homepage: Option<String>,
     documentation: Option<String>,
-    readme: Option<StringOrBool>,
+    readme: Option<String>,
     keywords: Option<Vec<String>>,
     categories: Option<Vec<String>>,
     license: Option<String>,
-    #[serde(rename = "license-file")]
     license_file: Option<String>,
     repository: Option<String>,
     metadata: Option<toml::Value>,
     resolver: Option<String>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+impl DefinedTomlPackage {
+    fn from_toml_project(
+        project: TomlProject,
+        ws: Option<&TomlWorkspace>,
+        root_path: Option<&Path>,
+        package_root: &Path,
+    ) -> CargoResult<Self> {
+        let version = ws_default(Some(project.version), ws, |ws| &ws.version, "version")?
+            .ok_or_else(|| anyhow!("no version specified"))?;
+        let edition = ws_default(project.edition, ws, |ws| &ws.edition, "edition")?;
+        let authors = ws_default(project.authors, ws, |ws| &ws.authors, "authors")?;
+        let publish = ws_default(project.publish, ws, |ws| &ws.publish, "publish")?;
+        let description = ws_default(project.description, ws, |ws| &ws.description, "description")?;
+        let homepage = ws_default(project.homepage, ws, |ws| &ws.homepage, "homepage")?;
+        let documentation = ws_default(
+            project.documentation,
+            ws,
+            |ws| &ws.documentation,
+            "documentation",
+        )?;
+
+        let readme = match (project.readme, ws.and_then(|ws| ws.readme.as_ref())) {
+            (None, _) => default_readme_from_package_root(package_root),
+            (Some(MaybeWorkspace::Defined(defined)), _) => defined.string_or_default("README.md"),
+            (Some(MaybeWorkspace::Workspace), None) => {
+                bail!("error reading readme: workspace root does not defined [workspace.readme]")
+            }
+            (Some(MaybeWorkspace::Workspace), Some(defined)) => {
+                match defined.string_or_default("README.md") {
+                    Some(ws_readme) => Some(join_relative_path(root_path, &ws_readme)?),
+                    None => None,
+                }
+            }
+        };
+
+        let license_file = match (
+            project.license_file,
+            ws.and_then(|ws| ws.license_file.as_ref()),
+        ) {
+            (None, _) => None,
+            (Some(MaybeWorkspace::Defined(defined)), _) => Some(defined),
+            (Some(MaybeWorkspace::Workspace), None) => {
+                bail!("error reading license-file: workspace root does not defined [workspace.license-file]");
+            }
+            (Some(MaybeWorkspace::Workspace), Some(ws_license_file)) => {
+                Some(join_relative_path(root_path, ws_license_file)?)
+            }
+        };
+
+        let keywords = ws_default(project.keywords, ws, |ws| &ws.keywords, "keywords")?;
+        let categories = ws_default(project.categories, ws, |ws| &ws.categories, "categories")?;
+        let license = ws_default(project.license, ws, |ws| &ws.license, "license")?;
+        let repository = ws_default(project.repository, ws, |ws| &ws.repository, "repository")?;
+
+        Ok(Self {
+            version,
+            edition,
+            name: project.name,
+            authors,
+            build: project.build,
+            metabuild: project.metabuild,
+            links: project.links,
+            exclude: project.exclude,
+            include: project.include,
+            publish,
+            publish_lockfile: project.publish_lockfile,
+            workspace: project.workspace,
+            im_a_teapot: project.im_a_teapot,
+            autobins: project.autobins,
+            autoexamples: project.autoexamples,
+            autotests: project.autotests,
+            autobenches: project.autobenches,
+            namespaced_features: project.namespaced_features,
+            default_run: project.default_run,
+
+            // Package metadata.
+            description,
+            homepage,
+            documentation,
+            readme,
+            keywords,
+            categories,
+            license,
+            license_file,
+            repository,
+            metadata: project.metadata,
+            resolver: project.resolver,
+        })
+    }
+}
+
+fn join_relative_path(root_path: Option<&Path>, relative_path: &str) -> CargoResult<String> {
+    paths::normalize_path(&root_path.unwrap().parent().unwrap().join(relative_path))
+        .into_os_string()
+        .into_string()
+        .map_err(|_| anyhow!("could not convert path into `String`"))
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct TomlWorkspace {
-    members: Option<Vec<String>>,
+    pub members: Option<Vec<String>>,
     #[serde(rename = "default-members")]
-    default_members: Option<Vec<String>>,
-    exclude: Option<Vec<String>>,
-    metadata: Option<toml::Value>,
+    pub default_members: Option<Vec<String>>,
+    pub exclude: Option<Vec<String>>,
+    pub metadata: Option<toml::Value>,
     resolver: Option<String>,
-}
 
-impl TomlProject {
-    pub fn to_package_id(&self, source_id: SourceId) -> CargoResult<PackageId> {
-        PackageId::new(self.name, self.version.clone(), source_id)
-    }
+    // Properties that can be inherited by members.
+    pub dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    pub version: Option<semver::Version>,
+    pub authors: Option<Vec<String>>,
+    pub description: Option<String>,
+    pub documentation: Option<String>,
+    pub readme: Option<StringOrBool>,
+    pub homepage: Option<String>,
+    pub repository: Option<String>,
+    pub license: Option<String>,
+    #[serde(rename = "license-file")]
+    pub license_file: Option<String>,
+    pub keywords: Option<Vec<String>>,
+    pub categories: Option<Vec<String>>,
+    pub publish: Option<VecStringOrBool>,
+    pub edition: Option<String>,
+    pub badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
 }
 
 struct Context<'a, 'b> {
@@ -848,19 +1465,16 @@ struct Context<'a, 'b> {
     features: &'a Features,
 }
 
-impl TomlManifest {
+impl DefinedTomlManifest {
     pub fn prepare_for_publish(
         &self,
         ws: &Workspace<'_>,
-        package_root: &Path,
-    ) -> CargoResult<TomlManifest> {
+        manifest_file: &Path,
+    ) -> CargoResult<DefinedTomlManifest> {
+        let package_root = manifest_file.parent().unwrap();
         let config = ws.config();
-        let mut package = self
-            .package
-            .as_ref()
-            .or_else(|| self.project.as_ref())
-            .unwrap()
-            .clone();
+        let mut package = self.package.clone().unwrap();
+
         package.workspace = None;
         let mut cargo_features = self.cargo_features.clone();
         package.resolver = ws.resolve_behavior().to_manifest();
@@ -875,6 +1489,7 @@ impl TomlManifest {
                 }
             }
         }
+
         if let Some(license_file) = &package.license_file {
             let license_path = Path::new(&license_file);
             let abs_license_path = paths::normalize_path(&package_root.join(license_path));
@@ -891,33 +1506,22 @@ impl TomlManifest {
                 );
             }
         }
-        let all = |_d: &TomlDependency| true;
-        return Ok(TomlManifest {
+        let all = |_d: &DefinedTomlDependency| true;
+        Ok(DefinedTomlManifest {
             package: Some(package),
-            project: None,
             profile: self.profile.clone(),
             lib: self.lib.clone(),
             bin: self.bin.clone(),
             example: self.example.clone(),
             test: self.test.clone(),
             bench: self.bench.clone(),
-            dependencies: map_deps(config, self.dependencies.as_ref(), all)?,
-            dev_dependencies: map_deps(
+            dependencies: prepare_deps(config, self.dependencies.as_ref(), all)?,
+            dev_dependencies: prepare_deps(
                 config,
-                self.dev_dependencies
-                    .as_ref()
-                    .or_else(|| self.dev_dependencies2.as_ref()),
-                TomlDependency::is_version_specified,
-            )?,
-            dev_dependencies2: None,
-            build_dependencies: map_deps(
-                config,
-                self.build_dependencies
-                    .as_ref()
-                    .or_else(|| self.build_dependencies2.as_ref()),
-                all,
+                self.dev_dependencies.as_ref(),
+                DefinedTomlDependency::is_version_specified,
             )?,
-            build_dependencies2: None,
+            build_dependencies: prepare_deps(config, self.build_dependencies.as_ref(), all)?,
             features: self.features.clone(),
             target: match self.target.as_ref().map(|target_map| {
                 target_map
@@ -925,17 +1529,17 @@ impl TomlManifest {
                     .map(|(k, v)| {
                         Ok((
                             k.clone(),
-                            TomlPlatform {
-                                dependencies: map_deps(config, v.dependencies.as_ref(), all)?,
-                                dev_dependencies: map_deps(
+                            DefinedTomlPlatform {
+                                dependencies: prepare_deps(config, v.dependencies.as_ref(), all)?,
+                                dev_dependencies: prepare_deps(
                                     config,
                                     v.dev_dependencies
                                         .as_ref()
                                         .or_else(|| v.dev_dependencies2.as_ref()),
-                                    TomlDependency::is_version_specified,
+                                    DefinedTomlDependency::is_version_specified,
                                 )?,
                                 dev_dependencies2: None,
-                                build_dependencies: map_deps(
+                                build_dependencies: prepare_deps(
                                     config,
                                     v.build_dependencies
                                         .as_ref()
@@ -957,57 +1561,17 @@ impl TomlManifest {
             workspace: None,
             badges: self.badges.clone(),
             cargo_features,
-        });
-
-        fn map_deps(
-            config: &Config,
-            deps: Option<&BTreeMap<String, TomlDependency>>,
-            filter: impl Fn(&TomlDependency) -> bool,
-        ) -> CargoResult<Option<BTreeMap<String, TomlDependency>>> {
-            let deps = match deps {
-                Some(deps) => deps,
-                None => return Ok(None),
-            };
-            let deps = deps
-                .iter()
-                .filter(|(_k, v)| filter(v))
-                .map(|(k, v)| Ok((k.clone(), map_dependency(config, v)?)))
-                .collect::<CargoResult<BTreeMap<_, _>>>()?;
-            Ok(Some(deps))
-        }
-
-        fn map_dependency(config: &Config, dep: &TomlDependency) -> CargoResult<TomlDependency> {
-            match dep {
-                TomlDependency::Detailed(d) => {
-                    let mut d = d.clone();
-                    // Path dependencies become crates.io deps.
-                    d.path.take();
-                    // Same with git dependencies.
-                    d.git.take();
-                    d.branch.take();
-                    d.tag.take();
-                    d.rev.take();
-                    // registry specifications are elaborated to the index URL
-                    if let Some(registry) = d.registry.take() {
-                        let src = SourceId::alt_registry(config, &registry)?;
-                        d.registry_index = Some(src.url().to_string());
-                    }
-                    Ok(TomlDependency::Detailed(d))
-                }
-                TomlDependency::Simple(s) => Ok(TomlDependency::Detailed(DetailedTomlDependency {
-                    version: Some(s.clone()),
-                    ..Default::default()
-                })),
-            }
-        }
+        })
     }
 
-    pub fn to_real_manifest(
-        me: &Rc<TomlManifest>,
+    pub fn into_real_manifest(
+        self,
         source_id: SourceId,
-        package_root: &Path,
+        manifest_file: &Path,
         config: &Config,
     ) -> CargoResult<(Manifest, Vec<PathBuf>)> {
+        let me = Rc::new(self);
+        let package_root = manifest_file.parent().unwrap();
         let mut nested_paths = vec![];
         let mut warnings = vec![];
         let mut errors = vec![];
@@ -1015,10 +1579,9 @@ impl TomlManifest {
         // Parse features first so they will be available when parsing other parts of the TOML.
         let empty = Vec::new();
         let cargo_features = me.cargo_features.as_ref().unwrap_or(&empty);
-        let features = Features::new(cargo_features, &mut warnings)?;
+        let features = Features::new(&cargo_features, &mut warnings)?;
 
-        let project = me.project.as_ref().or_else(|| me.package.as_ref());
-        let project = project.ok_or_else(|| anyhow!("no `package` section found"))?;
+        let project = me.package.as_ref().unwrap();
 
         let package_name = project.name.trim();
         if package_name.is_empty() {
@@ -1027,7 +1590,7 @@ impl TomlManifest {
 
         validate_package_name(package_name, "package name", "")?;
 
-        let pkgid = project.to_package_id(source_id)?;
+        let pkgid = PackageId::new(project.name, &project.version, source_id)?;
 
         let edition = if let Some(ref edition) = project.edition {
             features
@@ -1052,6 +1615,7 @@ impl TomlManifest {
         {
             features.require(Feature::resolver())?;
         }
+
         let resolve_behavior = match (
             project.resolver.as_ref(),
             me.workspace.as_ref().and_then(|ws| ws.resolver.as_ref()),
@@ -1068,7 +1632,7 @@ impl TomlManifest {
         // If we have a lib with no path, use the inferred lib or else the package name.
         let targets = targets(
             &features,
-            me,
+            &me,
             package_name,
             package_root,
             edition,
@@ -1120,7 +1684,7 @@ impl TomlManifest {
 
             fn process_dependencies(
                 cx: &mut Context<'_, '_>,
-                new_deps: Option<&BTreeMap<String, TomlDependency>>,
+                new_deps: Option<&BTreeMap<String, DefinedTomlDependency>>,
                 kind: Option<DepKind>,
             ) -> CargoResult<()> {
                 let dependencies = match new_deps {
@@ -1138,15 +1702,9 @@ impl TomlManifest {
 
             // Collect the dependencies.
             process_dependencies(&mut cx, me.dependencies.as_ref(), None)?;
-            let dev_deps = me
-                .dev_dependencies
-                .as_ref()
-                .or_else(|| me.dev_dependencies2.as_ref());
+            let dev_deps = me.dev_dependencies.as_ref();
             process_dependencies(&mut cx, dev_deps, Some(DepKind::Development))?;
-            let build_deps = me
-                .build_dependencies
-                .as_ref()
-                .or_else(|| me.build_dependencies2.as_ref());
+            let build_deps = me.build_dependencies.as_ref();
             process_dependencies(&mut cx, build_deps, Some(DepKind::Build))?;
 
             for (name, platform) in me.target.iter().flatten() {
@@ -1203,6 +1761,7 @@ impl TomlManifest {
                     .collect()
             })
             .unwrap_or_else(BTreeMap::new);
+
         let summary = Summary::new(
             pkgid,
             deps,
@@ -1215,7 +1774,7 @@ impl TomlManifest {
             description: project.description.clone(),
             homepage: project.homepage.clone(),
             documentation: project.documentation.clone(),
-            readme: readme_for_project(package_root, project),
+            readme: project.readme.clone(),
             authors: project.authors.clone().unwrap_or_default(),
             license: project.license.clone(),
             license_file: project.license_file.clone(),
@@ -1226,26 +1785,13 @@ impl TomlManifest {
             links: project.links.clone(),
         };
 
-        let workspace_config = match (me.workspace.as_ref(), project.workspace.as_ref()) {
-            (Some(config), None) => WorkspaceConfig::Root(WorkspaceRootConfig::new(
-                package_root,
-                &config.members,
-                &config.default_members,
-                &config.exclude,
-                &config.metadata,
-            )),
-            (None, root) => WorkspaceConfig::Member {
-                root: root.cloned(),
-            },
-            (Some(..), Some(..)) => bail!(
-                "cannot configure both `package.workspace` and \
-                 `[workspace]`, only one can be specified"
-            ),
-        };
+        let workspace_config = me.workspace_config(package_root, &config)?;
+
         let profiles = me.profile.clone();
         if let Some(profiles) = &profiles {
             profiles.validate(&features, &mut warnings)?;
         }
+
         let publish = match project.publish {
             Some(VecStringOrBool::VecString(ref vecstring)) => Some(vecstring.clone()),
             Some(VecStringOrBool::Bool(false)) => Some(vec![]),
@@ -1299,12 +1845,12 @@ impl TomlManifest {
             publish_lockfile,
             replace,
             patch,
-            workspace_config,
+            Rc::new(workspace_config),
             features,
             edition,
             project.im_a_teapot,
             project.default_run.clone(),
-            Rc::clone(me),
+            Rc::clone(&me),
             project.metabuild.clone().map(|sov| sov.0),
             resolve_behavior,
         );
@@ -1327,49 +1873,47 @@ impl TomlManifest {
         Ok((manifest, nested_paths))
     }
 
-    fn to_virtual_manifest(
-        me: &Rc<TomlManifest>,
+    fn into_virtual_manifest(
+        self,
         source_id: SourceId,
-        root: &Path,
+        manifest_file: &Path,
         config: &Config,
     ) -> CargoResult<(VirtualManifest, Vec<PathBuf>)> {
-        if me.project.is_some() {
+        let root = manifest_file.parent().unwrap();
+        if self.package.is_some() {
             bail!("this virtual manifest specifies a [project] section, which is not allowed");
         }
-        if me.package.is_some() {
-            bail!("this virtual manifest specifies a [package] section, which is not allowed");
-        }
-        if me.lib.is_some() {
+        if self.lib.is_some() {
             bail!("this virtual manifest specifies a [lib] section, which is not allowed");
         }
-        if me.bin.is_some() {
+        if self.bin.is_some() {
             bail!("this virtual manifest specifies a [[bin]] section, which is not allowed");
         }
-        if me.example.is_some() {
+        if self.example.is_some() {
             bail!("this virtual manifest specifies a [[example]] section, which is not allowed");
         }
-        if me.test.is_some() {
+        if self.test.is_some() {
             bail!("this virtual manifest specifies a [[test]] section, which is not allowed");
         }
-        if me.bench.is_some() {
+        if self.bench.is_some() {
             bail!("this virtual manifest specifies a [[bench]] section, which is not allowed");
         }
-        if me.dependencies.is_some() {
+        if self.dependencies.is_some() {
             bail!("this virtual manifest specifies a [dependencies] section, which is not allowed");
         }
-        if me.dev_dependencies.is_some() || me.dev_dependencies2.is_some() {
+        if self.dev_dependencies.is_some() {
             bail!("this virtual manifest specifies a [dev-dependencies] section, which is not allowed");
         }
-        if me.build_dependencies.is_some() || me.build_dependencies2.is_some() {
+        if self.build_dependencies.is_some() {
             bail!("this virtual manifest specifies a [build-dependencies] section, which is not allowed");
         }
-        if me.features.is_some() {
+        if self.features.is_some() {
             bail!("this virtual manifest specifies a [features] section, which is not allowed");
         }
-        if me.target.is_some() {
+        if self.target.is_some() {
             bail!("this virtual manifest specifies a [target] section, which is not allowed");
         }
-        if me.badges.is_some() {
+        if self.badges.is_some() {
             bail!("this virtual manifest specifies a [badges] section, which is not allowed");
         }
 
@@ -1377,7 +1921,7 @@ impl TomlManifest {
         let mut warnings = Vec::new();
         let mut deps = Vec::new();
         let empty = Vec::new();
-        let cargo_features = me.cargo_features.as_ref().unwrap_or(&empty);
+        let cargo_features = self.cargo_features.as_ref().unwrap_or(&empty);
         let features = Features::new(cargo_features, &mut warnings)?;
 
         let (replace, patch) = {
@@ -1392,42 +1936,36 @@ impl TomlManifest {
                 features: &features,
                 root,
             };
-            (me.replace(&mut cx)?, me.patch(&mut cx)?)
+            (self.replace(&mut cx)?, self.patch(&mut cx)?)
         };
-        let profiles = me.profile.clone();
+        let profiles = self.profile.clone();
         if let Some(profiles) = &profiles {
             profiles.validate(&features, &mut warnings)?;
         }
-        if me
+        if self
             .workspace
             .as_ref()
             .map_or(false, |ws| ws.resolver.is_some())
         {
             features.require(Feature::resolver())?;
         }
-        let resolve_behavior = me
+        let resolve_behavior = self
             .workspace
             .as_ref()
             .and_then(|ws| ws.resolver.as_deref())
             .map(|r| ResolveBehavior::from_manifest(r))
             .transpose()?;
-        let workspace_config = match me.workspace {
-            Some(ref config) => WorkspaceConfig::Root(WorkspaceRootConfig::new(
-                root,
-                &config.members,
-                &config.default_members,
-                &config.exclude,
-                &config.metadata,
-            )),
-            None => {
-                bail!("virtual manifests must be configured with [workspace]");
-            }
-        };
+
+        let workspace_config = self.workspace_config(root, config)?;
+        if !workspace_config.is_root() {
+            bail!("virtual manifests must be configured with [workspace]");
+        }
+
         Ok((
             VirtualManifest::new(
                 replace,
                 patch,
-                workspace_config,
+                Rc::new(workspace_config),
                 profiles,
                 features,
                 resolve_behavior,
@@ -1436,6 +1974,87 @@ impl TomlManifest {
         ))
     }
 
+    pub fn into_toml_manifest(self) -> TomlManifest {
+        let project = self.package.unwrap();
+
+        TomlManifest {
+            cargo_features: self.cargo_features,
+            package: Some(Box::new(TomlProject {
+                edition: MaybeWorkspace::from_option(&project.edition),
+                name: project.name,
+                version: MaybeWorkspace::Defined(project.version),
+                authors: MaybeWorkspace::from_option(&project.authors),
+                build: project.build,
+                metabuild: project.metabuild,
+                links: project.links,
+                exclude: project.exclude,
+                include: project.include,
+                publish: MaybeWorkspace::from_option(&project.publish),
+                publish_lockfile: project.publish_lockfile,
+                workspace: None,
+                im_a_teapot: project.im_a_teapot,
+                autobins: project.autobins,
+                autoexamples: project.autoexamples,
+                autotests: project.autotests,
+                autobenches: project.autobenches,
+                namespaced_features: project.namespaced_features,
+                default_run: project.default_run,
+
+                description: MaybeWorkspace::from_option(&project.description),
+                homepage: MaybeWorkspace::from_option(&project.homepage),
+                documentation: MaybeWorkspace::from_option(&project.documentation),
+                readme: MaybeWorkspace::from_option(&project.readme.map(StringOrBool::String)),
+                keywords: MaybeWorkspace::from_option(&project.keywords),
+                categories: MaybeWorkspace::from_option(&project.categories),
+                license: MaybeWorkspace::from_option(&project.license),
+                license_file: MaybeWorkspace::from_option(&project.license_file),
+                repository: MaybeWorkspace::from_option(&project.repository),
+                metadata: project.metadata,
+                resolver: project.resolver,
+            })),
+            project: None,
+            profile: self.profile,
+            lib: self.lib,
+            bin: self.bin,
+            example: self.example,
+            test: self.test,
+            bench: self.bench,
+            dependencies: to_toml_dependencies(self.dependencies.as_ref()),
+            dev_dependencies: to_toml_dependencies(self.dev_dependencies.as_ref()),
+            dev_dependencies2: None,
+            build_dependencies: to_toml_dependencies(self.build_dependencies.as_ref()),
+            build_dependencies2: None,
+            features: self.features,
+            target: to_toml_platform(self.target),
+            replace: self.replace,
+            patch: self.patch,
+            workspace: self.workspace,
+            badges: MaybeWorkspace::from_option(&self.badges),
+        }
+    }
+
+    pub fn workspace_config(
+        &self,
+        package_root: &Path,
+        config: &Config,
+    ) -> CargoResult<WorkspaceConfig> {
+        let workspace = self.workspace.as_ref();
+        let project_workspace = self.package.as_ref().and_then(|p| p.workspace.as_ref());
+
+        Ok(match (workspace, project_workspace) {
+            (Some(toml_workspace), None) => WorkspaceConfig::Root(
+                WorkspaceRootConfig::from_toml_workspace(package_root, &config, toml_workspace)?,
+            ),
+            (None, root) => WorkspaceConfig::Member {
+                root: root.cloned(),
+            },
+            (Some(..), Some(..)) => bail!(
+                "cannot configure both `package.workspace` and \
+                 `[workspace]`, only one can be specified"
+            ),
+        })
+    }
+
     fn replace(&self, cx: &mut Context<'_, '_>) -> CargoResult<Vec<(PackageIdSpec, Dependency)>> {
         if self.patch.is_some() && self.replace.is_some() {
             bail!("cannot specify both [replace] and [patch]");
@@ -1528,18 +2147,6 @@ impl TomlManifest {
     }
 }
 
-/// Returns the name of the README file for a `TomlProject`.
-fn readme_for_project(package_root: &Path, project: &TomlProject) -> Option<String> {
-    match &project.readme {
-        None => default_readme_from_package_root(package_root),
-        Some(value) => match value {
-            StringOrBool::Bool(false) => None,
-            StringOrBool::Bool(true) => Some("README.md".to_string()),
-            StringOrBool::String(v) => Some(v.clone()),
-        },
-    }
-}
-
 const DEFAULT_README_FILES: [&str; 3] = ["README.md", "README.txt", "README"];
 
 /// Checks if a file with any of the default README file names exists in the package root.
@@ -1570,6 +2177,94 @@ fn unique_build_targets(targets: &[Target], package_root: &Path) -> Result<(), S
 }
 
 impl TomlDependency {
+    fn from_defined_dependency(dep: &DefinedTomlDependency) -> Self {
+        match dep {
+            DefinedTomlDependency::Simple(s) => Self::Simple(s.clone()),
+            DefinedTomlDependency::Detailed(detailed) => Self::Detailed(detailed.clone()),
+        }
+    }
+}
+
+impl DefinedTomlDependency {
+    fn from_toml_dependency(
+        dep: &TomlDependency,
+        name: &str,
+        ctx: &WorkspaceContext<'_>,
+    ) -> CargoResult<Self> {
+        match dep {
+            TomlDependency::Simple(s) => Ok(Self::Simple(s.clone())),
+            TomlDependency::Detailed(details) => {
+                let mut details = details.clone();
+                details.infer_path_version(ctx)?;
+                Ok(Self::Detailed(details))
+            }
+            TomlDependency::Workspace(ws) => {
+                let ws_dep = ctx.dependencies.get(name).ok_or_else(|| {
+                    anyhow!(
+                        "could not find entry in [workspace.dependencies] for \"{}\"",
+                        name
+                    )
+                })?;
+
+                Self::from_workspace_dependency(ws, ws_dep, ctx)
+            }
+        }
+    }
+
+    fn from_workspace_dependency(
+        details: &WorkspaceDetails,
+        ws_dep: &Self,
+        ctx: &WorkspaceContext<'_>,
+    ) -> CargoResult<Self> {
+        let mut details = match ws_dep {
+            Self::Simple(s) => TomlDependencyDetails {
+                version: Some(s.clone()),
+                features: details
+                    .features
+                    .clone()
+                    .or_else(|| ws_dep.features().cloned()),
+                optional: details.optional.or_else(|| Some(ws_dep.is_optional())),
+                ..Default::default()
+            },
+
+            Self::Detailed(d) => TomlDependencyDetails {
+                version: d.version.clone(),
+                registry: d.registry.clone(),
+                registry_index: d.registry_index.clone(),
+                path: d
+                    .path
+                    .clone()
+                    .map(|p| join_relative_path(ctx.root_path, &p))
+                    .transpose()?,
+                git: d.git.clone(),
+                branch: d.branch.clone(),
+                tag: d.tag.clone(),
+                rev: d.rev.clone(),
+                features: match (&details.features, &d.features) {
+                    (None, None) => None,
+                    (Some(features), None) | (None, Some(features)) => Some(features.clone()),
+                    (Some(ws_features), Some(features)) => {
+                        let mut result = ws_features.clone();
+                        for f in features {
+                            if !result.contains(&f) {
+                                result.push(f.clone());
+                            }
+                        }
+                        Some(result)
+                    }
+                },
+                optional: details.optional.or_else(|| d.optional.clone()),
+                default_features: d.default_features.clone(),
+                default_features2: d.default_features2.clone(),
+                package: d.package.clone(),
+                public: d.public.clone(),
+            },
+        };
+
+        details.infer_path_version(ctx)?;
+        Ok(Self::Detailed(details))
+    }
+
     fn to_dependency(
         &self,
         name: &str,
@@ -1577,24 +2272,38 @@ impl TomlDependency {
         kind: Option<DepKind>,
     ) -> CargoResult<Dependency> {
         match *self {
-            TomlDependency::Simple(ref version) => DetailedTomlDependency {
+            DefinedTomlDependency::Simple(ref version) => TomlDependencyDetails {
                 version: Some(version.clone()),
                 ..Default::default()
             }
             .to_dependency(name, cx, kind),
-            TomlDependency::Detailed(ref details) => details.to_dependency(name, cx, kind),
+            DefinedTomlDependency::Detailed(ref details) => details.to_dependency(name, cx, kind),
         }
     }
 
     fn is_version_specified(&self) -> bool {
         match self {
-            TomlDependency::Detailed(d) => d.version.is_some(),
-            TomlDependency::Simple(..) => true,
+            DefinedTomlDependency::Detailed(d) => d.version.is_some(),
+            DefinedTomlDependency::Simple(..) => true,
+        }
+    }
+
+    fn is_optional(&self) -> bool {
+        match self {
+            DefinedTomlDependency::Detailed(d) => d.optional.unwrap_or(false),
+            DefinedTomlDependency::Simple(..) => false,
+        }
+    }
+
+    fn features(&self) -> Option<&Vec<String>> {
+        match self {
+            DefinedTomlDependency::Detailed(d) => d.features.as_ref(),
+            DefinedTomlDependency::Simple(..) => None,
         }
     }
 }
 
-impl DetailedTomlDependency {
+impl TomlDependencyDetails {
     fn to_dependency(
         &self,
         name_in_toml: &str,
@@ -1778,6 +2487,41 @@ impl DetailedTomlDependency {
         }
         Ok(dep)
     }
+
+    fn infer_path_version(&mut self, ctx: &WorkspaceContext<'_>) -> CargoResult<()> {
+        if let (None, Some(p)) = (&self.version, &self.path) {
+            let path_dep_manifest = ctx.package_root.join(p).join("Cargo.toml");
+            let manifest = parse_manifest(&path_dep_manifest, ctx.config)?.manifest;
+            let root_path = find_workspace_root(&path_dep_manifest, ctx.config)?;
+            let package = manifest.package.as_deref().or(manifest.project.as_deref());
+            let output = root_path
+                .map(|root_path| parse_manifest(&root_path, ctx.config))
+                .transpose()?;
+            let workspace = output.as_ref().and_then(|output| output.workspace());
+
+            let version = ws_default(
+                package.map(|p| p.version.clone()),
+                workspace,
+                |ws| &ws.version,
+                "version",
+            )?;
+
+            let publish = ws_default(
+                package.and_then(|p| p.publish.clone()),
+                workspace,
+                |ws| &ws.publish,
+                "publish",
+            )?;
+
+            self.version = match (version, publish) {
+                (None, _) => bail!("path dependency does not specify version"),
+                (_, Some(VecStringOrBool::Bool(false))) => None,
+                (Some(v), _) => Some(v.to_string()),
+            }
+        }
+
+        Ok(())
+    }
 }
 
 #[derive(Default, Serialize, Deserialize, Debug, Clone)]
@@ -1829,7 +2573,20 @@ impl ser::Serialize for PathValue {
 }
 
 /// Corresponds to a `target` entry, but `TomlTarget` is already used.
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
+struct DefinedTomlPlatform {
+    dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    #[serde(rename = "build-dependencies")]
+    build_dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    #[serde(rename = "build_dependencies")]
+    build_dependencies2: Option<BTreeMap<String, DefinedTomlDependency>>,
+    #[serde(rename = "dev-dependencies")]
+    dev_dependencies: Option<BTreeMap<String, DefinedTomlDependency>>,
+    #[serde(rename = "dev_dependencies")]
+    dev_dependencies2: Option<BTreeMap<String, DefinedTomlDependency>>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Debug)]
 struct TomlPlatform {
     dependencies: Option<BTreeMap<String, TomlDependency>>,
     #[serde(rename = "build-dependencies")]
@@ -1842,6 +2599,43 @@ struct TomlPlatform {
     dev_dependencies2: Option<BTreeMap<String, TomlDependency>>,
 }
 
+impl TomlPlatform {
+    fn from_defined_platform(defined_platform: &DefinedTomlPlatform) -> Self {
+        Self {
+            dependencies: to_toml_dependencies(defined_platform.dependencies.as_ref()),
+            build_dependencies: to_toml_dependencies(defined_platform.build_dependencies.as_ref()),
+            build_dependencies2: None,
+            dev_dependencies: to_toml_dependencies(defined_platform.dev_dependencies.as_ref()),
+            dev_dependencies2: None,
+        }
+    }
+}
+
+impl DefinedTomlPlatform {
+    fn from_toml_platform(
+        toml_platform: &TomlPlatform,
+        ctx: &WorkspaceContext<'_>,
+    ) -> CargoResult<Self> {
+        let build_dependencies = toml_platform
+            .build_dependencies
+            .as_ref()
+            .or(toml_platform.build_dependencies2.as_ref());
+
+        let dev_dependencies = toml_platform
+            .dev_dependencies
+            .as_ref()
+            .or(toml_platform.dev_dependencies2.as_ref());
+
+        Ok(Self {
+            dependencies: to_defined_dependencies(toml_platform.dependencies.as_ref(), ctx)?,
+            build_dependencies: to_defined_dependencies(build_dependencies, ctx)?,
+            build_dependencies2: None,
+            dev_dependencies: to_defined_dependencies(dev_dependencies, ctx)?,
+            dev_dependencies2: None,
+        })
+    }
+}
+
 impl TomlTarget {
     fn new() -> TomlTarget {
         TomlTarget::default()
diff --git a/src/cargo/util/toml/targets.rs b/src/cargo/util/toml/targets.rs
index a711acd556b..6d34a194da7 100644
--- a/src/cargo/util/toml/targets.rs
+++ b/src/cargo/util/toml/targets.rs
@@ -15,8 +15,8 @@ use std::fs::{self, DirEntry};
 use std::path::{Path, PathBuf};
 
 use super::{
-    PathValue, StringOrBool, StringOrVec, TomlBenchTarget, TomlBinTarget, TomlExampleTarget,
-    TomlLibTarget, TomlManifest, TomlTarget, TomlTestTarget,
+    DefinedTomlManifest, PathValue, StringOrBool, StringOrVec, TomlBenchTarget, TomlBinTarget,
+    TomlExampleTarget, TomlLibTarget, TomlTarget, TomlTestTarget,
 };
 use crate::core::compiler::CrateType;
 use crate::core::{Edition, Feature, Features, Target};
@@ -25,7 +25,7 @@ use crate::util::restricted_names;
 
 pub fn targets(
     features: &Features,
-    manifest: &TomlManifest,
+    manifest: &DefinedTomlManifest,
     package_name: &str,
     package_root: &Path,
     edition: Edition,
@@ -55,7 +55,6 @@ pub fn targets(
     let package = manifest
         .package
         .as_ref()
-        .or_else(|| manifest.project.as_ref())
         .ok_or_else(|| anyhow::format_err!("manifest has no `package` (or `project`)"))?;
 
     targets.extend(clean_bins(
diff --git a/tests/testsuite/bad_config.rs b/tests/testsuite/bad_config.rs
index 62f7c1b29e9..be2ba67d2f3 100644
--- a/tests/testsuite/bad_config.rs
+++ b/tests/testsuite/bad_config.rs
@@ -1103,6 +1103,8 @@ fn both_git_and_path_specified() {
     "#,
         )
         .file("src/lib.rs", "")
+        .file("bar/Cargo.toml", &basic_manifest("bar", "0.0.1"))
+        .file("bar/lib.rs", "")
         .build();
 
     foo.cargo("build -v")
@@ -1173,6 +1175,8 @@ fn ignored_git_revision() {
     "#,
         )
         .file("src/lib.rs", "")
+        .file("bar/Cargo.toml", &basic_manifest("bar", "0.0.1"))
+        .file("bar/lib.rs", "")
         .build();
 
     foo.cargo("build -v")
diff --git a/tests/testsuite/build_script.rs b/tests/testsuite/build_script.rs
index a54b5eed42b..bb2ab8de124 100644
--- a/tests/testsuite/build_script.rs
+++ b/tests/testsuite/build_script.rs
@@ -382,7 +382,7 @@ fn links_duplicates() {
                        .with_stderr("\
 error: failed to select a version for `a-sys`.
     ... required by package `foo v0.5.0 ([..])`
-versions that meet the requirements `*` are: 0.5.0
+versions that meet the requirements `^0.5.0` are: 0.5.0
 
 the package `a-sys` links to the native library `a`, but it conflicts with a previous package which links to `a` as well:
 package `foo v0.5.0 ([..])`
@@ -501,7 +501,7 @@ fn links_duplicates_deep_dependency() {
 error: failed to select a version for `a-sys`.
     ... required by package `a v0.5.0 ([..])`
     ... which is depended on by `foo v0.5.0 ([..])`
-versions that meet the requirements `*` are: 0.5.0
+versions that meet the requirements `^0.5.0` are: 0.5.0
 
 the package `a-sys` links to the native library `a`, but it conflicts with a previous package which links to `a` as well:
 package `foo v0.5.0 ([..])`
@@ -3579,7 +3579,7 @@ fn links_duplicates_with_cycle() {
                        .with_stderr("\
 error: failed to select a version for `a`.
     ... required by package `foo v0.5.0 ([..])`
-versions that meet the requirements `*` are: 0.5.0
+versions that meet the requirements `^0.5.0` are: 0.5.0
 
 the package `a` links to the native library `a`, but it conflicts with a previous package which links to `a` as well:
 package `foo v0.5.0 ([..])`
diff --git a/tests/testsuite/deduplicate_workspace.rs b/tests/testsuite/deduplicate_workspace.rs
new file mode 100644
index 00000000000..54f46bedb3b
--- /dev/null
+++ b/tests/testsuite/deduplicate_workspace.rs
@@ -0,0 +1,912 @@
+//! Tests for deduplicating Cargo.toml fields with { workspace = true }
+use cargo_test_support::registry::{Dependency, Package};
+use cargo_test_support::{
+    basic_lib_manifest, basic_manifest, basic_workspace_manifest, git, path2url, paths, project,
+    publish, registry,
+};
+
+#[cargo_test]
+fn permit_additional_workspace_fields() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+            version = "1.2.3"
+            authors = ["Rustaceans"]
+            description = "This is a crate"
+            documentation = "https://www.rust-lang.org/learn"
+            readme = "README.md"
+            homepage = "https://www.rust-lang.org"
+            repository = "https://github.com/example/example"
+            license = "MIT"
+            license-file = "./LICENSE"
+            keywords = ["cli"]
+            categories = ["development-tools"]
+            publish = false
+            edition = "2018"
+
+            [workspace.badges]
+            gitlab = { repository = "https://gitlab.com/rust-lang/rust", branch = "master" }
+
+            [workspace.dependencies]
+            dep = "0.1"
+        "#,
+        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", ".."))
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        // Should not warn about unused fields.
+        .with_stderr(
+            "\
+[COMPILING] bar v0.1.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    p.cargo("check").run();
+    let lockfile = p.read_lockfile();
+    assert!(!lockfile.contains("dep"));
+}
+
+#[cargo_test]
+fn deny_optional_dependencies() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep1 = { version = "0.1", optional = true }
+        "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", ".."))
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[..]foo/Cargo.toml`
+
+Caused by:
+  dep1 is optional, but workspace dependencies cannot be optional
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+// TODO Handle readme copying correctly.
+#[ignore]
+fn inherit_workspace_fields() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+            version = "1.2.3"
+            authors = ["Rustaceans"]
+            description = "This is a crate"
+            documentation = "https://www.rust-lang.org/learn"
+            readme = "README.md"
+            homepage = "https://www.rust-lang.org"
+            repository = "https://github.com/example/example"
+            license = "MIT"
+            license-file = "./LICENSE"
+            keywords = ["cli"]
+            categories = ["development-tools"]
+            publish = true
+            edition = "2018"
+
+            [workspace.badges]
+            gitlab = { repository = "https://gitlab.com/rust-lang/rust", branch = "master" }
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            badges = { workspace = true }
+
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = { workspace = true }
+            authors = { workspace = true }
+            description = { workspace = true }
+            documentation = { workspace = true }
+            readme = { workspace = true }
+            homepage = { workspace = true }
+            repository = { workspace = true }
+            license = { workspace = true }
+            license-file = { workspace = true }
+            keywords = { workspace = true }
+            categories = { workspace = true }
+            publish = { workspace = true }
+            edition = { workspace = true }
+        "#,
+        )
+        .file("LICENSE", "license")
+        .file("README.md", "README.md")
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("publish --token sekrit").cwd("bar").run();
+    publish::validate_upload(
+        r#"
+        {
+          "authors": ["Rustaceans"],
+          "badges": {
+            "gitlab": { "branch": "master", "repository": "https://gitlab.com/rust-lang/rust" }
+          },
+          "categories": ["development-tools"],
+          "deps": [],
+          "description": "This is a crate",
+          "documentation": "https://www.rust-lang.org/learn",
+          "features": {},
+          "homepage": "https://www.rust-lang.org",
+          "keywords": ["cli"],
+          "license": "MIT",
+          "license_file": "../LICENSE",
+          "links": null,
+          "name": "bar",
+          "readme": "README.md",
+          "readme_file": "../README.md",
+          "repository": "https://github.com/example/example",
+          "vers": "1.2.3"
+          }
+        "#,
+        "bar-1.2.3.crate",
+        &[
+            "Cargo.lock",
+            "Cargo.toml",
+            "Cargo.toml.orig",
+            "src/main.rs",
+            "README.md",
+            "LICENSE",
+            ".cargo_vcs_info.json",
+        ],
+    );
+}
+
+#[cargo_test]
+#[ignore]
+// TODO Handle readme copying correctly.
+fn inherit_own_workspace_fields() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            badges = { workspace = true }
+
+            [package]
+            name = "foo"
+            version = { workspace = true }
+            authors = { workspace = true }
+            description = { workspace = true }
+            documentation = { workspace = true }
+            readme = { workspace = true }
+            homepage = { workspace = true }
+            repository = { workspace = true }
+            license = { workspace = true }
+            license-file = { workspace = true }
+            keywords = { workspace = true }
+            categories = { workspace = true }
+            publish = { workspace = true }
+            edition = { workspace = true }
+
+            [workspace]
+            members = []
+            version = "1.2.3"
+            authors = ["Rustaceans"]
+            description = "This is a crate"
+            documentation = "https://www.rust-lang.org/learn"
+            readme = "README.md"
+            homepage = "https://www.rust-lang.org"
+            repository = "https://github.com/example/example"
+            license = "MIT"
+            license-file = "./LICENSE"
+            keywords = ["cli"]
+            categories = ["development-tools"]
+            publish = true
+            edition = "2018"
+
+            [workspace.badges]
+            gitlab = { repository = "https://gitlab.com/rust-lang/rust", branch = "master" }
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file("LICENSE", "license")
+        .file("README.md", "README.md")
+        .build();
+
+    p.cargo("publish --token sekrit").run();
+    publish::validate_upload(
+        r#"
+        {
+          "authors": ["Rustaceans"],
+          "badges": {
+            "gitlab": { "branch": "master", "repository": "https://gitlab.com/rust-lang/rust" }
+          },
+          "categories": ["development-tools"],
+          "deps": [],
+          "description": "This is a crate",
+          "documentation": "https://www.rust-lang.org/learn",
+          "features": {},
+          "homepage": "https://www.rust-lang.org",
+          "keywords": ["cli"],
+          "license": "MIT",
+          "license_file": "./LICENSE",
+          "links": null,
+          "name": "foo",
+          "readme": "README.md",
+          "readme_file": "README.md",
+          "repository": "https://github.com/example/example",
+          "vers": "1.2.3"
+          }
+        "#,
+        "foo-1.2.3.crate",
+        &[
+            "Cargo.lock",
+            "Cargo.toml",
+            "Cargo.toml.orig",
+            "src/main.rs",
+            "README.md",
+            "LICENSE",
+            ".cargo_vcs_info.json",
+        ],
+    );
+}
+
+#[cargo_test]
+fn inherit_dependencies() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep = "0.1"
+            dep-build = "0.8"
+            dep-dev = "0.5.2"
+        "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [dependencies]
+            dep = { workspace = true }
+
+            [build-dependencies]
+            dep-build = { workspace = true }
+
+            [dev-dependencies]
+            dep-dev = { workspace = true }
+
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    Package::new("dep", "0.1.2").publish();
+    Package::new("dep-build", "0.8.2").publish();
+    Package::new("dep-dev", "0.5.2").publish();
+
+    p.cargo("build")
+        .with_stderr(
+            "\
+[UPDATING] `[..]` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] dep-build v0.8.2 ([..])
+[DOWNLOADED] dep v0.1.2 ([..])
+[COMPILING] dep v0.1.2
+[COMPILING] bar v0.2.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    p.cargo("check").run();
+    let lockfile = p.read_lockfile();
+    assert!(lockfile.contains("dep"));
+    assert!(lockfile.contains("dep-dev"));
+    assert!(lockfile.contains("dep-build"));
+}
+
+#[cargo_test]
+fn inherite_detailed_dependencies() {
+    let git_project = git::new("detailed", |project| {
+        project
+            .file("Cargo.toml", &basic_lib_manifest("detailed"))
+            .file(
+                "src/detailed.rs",
+                r#"
+                pub fn hello() -> &'static str {
+                    "hello world"
+                }
+            "#,
+            )
+    });
+
+    // Make a new branch based on the current HEAD commit
+    let repo = git2::Repository::open(&git_project.root()).unwrap();
+    let head = repo.head().unwrap().target().unwrap();
+    let head = repo.find_commit(head).unwrap();
+    repo.branch("branchy", &head, true).unwrap();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            detailed = {{ git = '{}', branch = "branchy" }}
+        "#,
+                git_project.url()
+            ),
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [dependencies]
+            detailed = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    let git_root = git_project.root();
+
+    p.cargo("build")
+        .with_stderr(&format!(
+            "\
+[UPDATING] git repository `{}`\n\
+[COMPILING] detailed v0.5.0 ({}?branch=branchy#[..])\n\
+[COMPILING] bar v0.2.0 ([CWD]/bar)\n\
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]\n",
+            path2url(&git_root),
+            path2url(&git_root),
+        ))
+        .run();
+}
+
+#[cargo_test]
+fn inherit_path_dependencies() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep = { path = "dep" }
+        "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [dependencies]
+            dep = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .file("dep/Cargo.toml", &basic_manifest("dep", "0.9.0"))
+        .file("dep/src/lib.rs", "")
+        .build();
+
+    p.cargo("build")
+        .with_stderr(
+            "\
+[COMPILING] dep v0.9.0 ([CWD]/dep)
+[COMPILING] bar v0.2.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    let lockfile = p.read_lockfile();
+    assert!(lockfile.contains("dep"));
+}
+
+#[cargo_test]
+fn inherit_target_dependencies() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep = "0.1"
+        "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [target.'cfg(unix)'.dependencies]
+            dep = { workspace = true }
+
+            [target.'cfg(windows)'.dependencies]
+            dep = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    Package::new("dep", "0.1.2").publish();
+
+    p.cargo("build")
+        .with_stderr(
+            "\
+[UPDATING] `[..]` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] dep v0.1.2 ([..])
+[COMPILING] dep v0.1.2
+[COMPILING] bar v0.2.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    let lockfile = p.read_lockfile();
+    assert!(lockfile.contains("dep"));
+}
+
+#[cargo_test]
+fn inherited_dependencies_union_features() {
+    Package::new("dep", "0.1.0")
+        .feature("fancy", &["fancy_dep"])
+        .feature("dancy", &["dancy_dep"])
+        .add_dep(Dependency::new("fancy_dep", "0.2").optional(true))
+        .add_dep(Dependency::new("dancy_dep", "0.6").optional(true))
+        .file("src/lib.rs", "")
+        .publish();
+
+    Package::new("fancy_dep", "0.2.4").publish();
+    Package::new("dancy_dep", "0.6.8").publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep = { version = "0.1", features = ["fancy"] }
+        "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [dependencies]
+            dep = { workspace = true, features = ["dancy"] }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .with_stderr(
+            "\
+[UPDATING] `[..]` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] fancy_dep v0.2.4 ([..])
+[DOWNLOADED] dep v0.1.0 ([..])
+[DOWNLOADED] dancy_dep v0.6.8 ([..])
+[COMPILING] [..]
+[COMPILING] [..]
+[COMPILING] dep v0.1.0
+[COMPILING] bar v0.2.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    let lockfile = p.read_lockfile();
+    assert!(lockfile.contains("dep"));
+    assert!(lockfile.contains("fancy_dep"));
+    assert!(lockfile.contains("dancy_dep"));
+}
+
+#[cargo_test]
+fn inherited_dependency_override_optional() {
+    Package::new("dep", "0.1.0").publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+
+            [workspace.dependencies]
+            dep = "0.1.0"
+        "#,
+        )
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [project]
+            workspace = ".."
+            name = "bar"
+            version = "0.2.0"
+            authors = []
+
+            [dependencies]
+            dep = { workspace = true, optional = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .with_stderr(
+            "\
+[UPDATING] `[..]` index
+[COMPILING] bar v0.2.0 ([CWD]/bar)
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn path_dependency_has_workspace_version() {
+    let p = project()
+        .file(
+            "foo_root/Cargo.toml",
+            r#"
+            [workspace]
+            members = ["foo_member"]
+            version = "0.4.5"
+        "#,
+        )
+        .file(
+            "foo_member/Cargo.toml",
+            r#"
+            [project]
+            workspace = "../foo_root"
+            name = "foo_member"
+            version = { workspace = true }
+            authors = []
+        "#,
+        )
+        .file("foo_member/src/main.rs", "fn main() {}")
+        .file(
+            "Cargo.toml",
+            r#"
+            [project]
+            name = "baz"
+            version = "0.1.2"
+
+            [dependencies]
+            foo_member = { path = "./foo_member" }
+        "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .build();
+
+    Package::new("foo_member", "0.4.5").publish();
+    p.cargo("package")
+        .with_stderr(
+            "\
+[WARNING] [..]
+[..]
+[PACKAGING] baz [..]
+[UPDATING] `[..]` index
+[VERIFYING] baz [..]
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo_member v0.4.5 [..]
+[COMPILING] foo_member v0.4.5
+[COMPILING] baz v0.1.2 [..]
+[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_malformed_workspace_root() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = [invalid toml
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = "1.2.3"
+            authors = ["rustaceans"]
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .cwd("bar")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[..]/foo/bar/Cargo.toml`
+
+Caused by:
+  failed to parse manifest at `[..]/foo/Cargo.toml`
+
+Caused by:
+  [..]
+
+Caused by:
+  [..]
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_inherit_from_undefined_field() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = "1.2.3"
+            authors = ["rustaceans"]
+            description = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .cwd("bar")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
+
+Caused by:
+  error reading `description` from workspace root manifest's `[workspace.description]`
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_workspace_false() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = "1.2.3"
+            authors = ["rustaceans"]
+            description = { workspace = false }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .cwd("bar")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
+
+Caused by:
+  workspace cannot be false for key `package.description`
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_no_root_workspace() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = "1.2.3"
+            authors = ["rustaceans"]
+            description = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .cwd("bar")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
+
+Caused by:
+  error reading description: could not find workspace root
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_badges_wrapping() {
+    registry::init();
+
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            version = "1.2.3"
+            authors = ["rustaceans"]
+
+            [badges]
+            gitlab = "1.2.3"
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
+
+Caused by:
+  expected a table of badges or { workspace = true } for key `badges`
+",
+        )
+        .run();
+}
+
+#[cargo_test]
+fn error_inherit_unspecified_dependency() {
+    let p = project().build();
+
+    let _ = git::repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["bar"]
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .file(
+            "bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            workspace = ".."
+            version = "1.2.3"
+            authors = ["rustaceans"]
+
+            [dependencies]
+            foo = { workspace = true }
+        "#,
+        )
+        .file("bar/src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("build")
+        .cwd("bar")
+        .with_status(101)
+        .with_stderr(
+            "\
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
+
+Caused by:
+  failed to get dependency `foo`
+
+Caused by:
+  could not find entry in [workspace.dependencies] for \"foo\"
+",
+        )
+        .run();
+}
diff --git a/tests/testsuite/features.rs b/tests/testsuite/features.rs
index b75c4829191..363e8cde812 100644
--- a/tests/testsuite/features.rs
+++ b/tests/testsuite/features.rs
@@ -54,6 +54,8 @@ fn invalid2() {
         "#,
         )
         .file("src/main.rs", "")
+        .file("foo/Cargo.toml", &basic_manifest("foo", "0.1.2"))
+        .file("foo/src/lib.rs", "")
         .build();
 
     p.cargo("build")
@@ -88,6 +90,8 @@ fn invalid3() {
         "#,
         )
         .file("src/main.rs", "")
+        .file("foo/Cargo.toml", &basic_manifest("foo", "0.1.2"))
+        .file("foo/src/lib.rs", "")
         .build();
 
     p.cargo("build")
@@ -131,7 +135,7 @@ fn invalid4() {
             "\
 error: failed to select a version for `bar`.
     ... required by package `foo v0.0.1 ([..])`
-versions that meet the requirements `*` are: 0.0.1
+versions that meet the requirements `^0.0.1` are: 0.0.1
 
 the package `foo` depends on `bar`, with features: `bar` but `bar` does not have these features.
 
@@ -165,6 +169,8 @@ fn invalid5() {
         "#,
         )
         .file("src/main.rs", "")
+        .file("bar/Cargo.toml", &basic_manifest("bar", "0.0.1"))
+        .file("bar/src/lib.rs", "")
         .build();
 
     p.cargo("build")
@@ -335,7 +341,7 @@ fn invalid10() {
     p.cargo("build").with_stderr("\
 error: failed to select a version for `bar`.
     ... required by package `foo v0.0.1 ([..])`
-versions that meet the requirements `*` are: 0.0.1
+versions that meet the requirements `^0.0.1` are: 0.0.1
 
 the package `foo` depends on `bar`, with features: `baz` but `bar` does not have these features.
  It has a required dependency with that name, but only optional dependencies can be used as features.
diff --git a/tests/testsuite/main.rs b/tests/testsuite/main.rs
index 78379e8a01f..5cc2960bb68 100644
--- a/tests/testsuite/main.rs
+++ b/tests/testsuite/main.rs
@@ -38,6 +38,7 @@ mod cross_compile;
 mod cross_publish;
 mod custom_target;
 mod death;
+mod deduplicate_workspace;
 mod dep_info;
 mod directory;
 mod doc;
diff --git a/tests/testsuite/metadata.rs b/tests/testsuite/metadata.rs
index 8e5e236aae7..e8bad6f6f56 100644
--- a/tests/testsuite/metadata.rs
+++ b/tests/testsuite/metadata.rs
@@ -1902,7 +1902,7 @@ fn deps_with_bin_only() {
         {
           "name": "bdep",
           "source": null,
-          "req": "*",
+          "req": "^0.5.0",
           "kind": null,
           "rename": null,
           "optional": false,
diff --git a/tests/testsuite/package.rs b/tests/testsuite/package.rs
index a2224abd858..de969ad83cc 100644
--- a/tests/testsuite/package.rs
+++ b/tests/testsuite/package.rs
@@ -259,37 +259,50 @@ in package source
 
 #[cargo_test]
 fn path_dependency_no_version() {
+    Package::new("bar", "0.1.0").publish();
     let p = project()
         .file(
             "Cargo.toml",
             r#"
-            [project]
-            name = "foo"
-            version = "0.0.1"
-            authors = []
-            license = "MIT"
-            description = "foo"
+             [project]
+             name = "foo"
+             version = "0.0.1"
+             authors = []
+             license = "MIT"
+             description = "foo"
 
-            [dependencies.bar]
-            path = "bar"
-        "#,
+             [dependencies.bar]
+             path = "bar"
+         "#,
         )
         .file("src/main.rs", "fn main() {}")
         .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
         .file("bar/src/lib.rs", "")
         .build();
 
-    p.cargo("package")
-        .with_status(101)
-        .with_stderr(
-            "\
-[WARNING] manifest has no documentation, homepage or repository.
-See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
-[ERROR] all path dependencies must have a version specified when packaging.
-dependency `bar` does not specify a version.
-",
-        )
-        .run();
+    p.cargo("package --no-verify").run();
+
+    let f = File::open(&p.root().join("target/package/foo-0.0.1.crate")).unwrap();
+    let rewritten_toml = format!(
+        r#"{}
+[package]
+name = "foo"
+version = "0.0.1"
+authors = []
+description = "foo"
+license = "MIT"
+[dependencies.bar]
+version = "0.1.0"
+"#,
+        cargo::core::package::MANIFEST_PREAMBLE,
+    );
+
+    validate_crate_contents(
+        f,
+        "foo-0.0.1.crate",
+        &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
+        &[("Cargo.toml", &rewritten_toml)],
+    );
 }
 
 #[cargo_test]
@@ -1813,15 +1826,21 @@ fn list_with_path_and_lock() {
             version = "0.1.0"
             license = "MIT"
             description = "foo"
-            homepage = "foo"
-
-            [dependencies]
-            bar = {path="bar"}
             "#,
         )
         .file("src/main.rs", "fn main() {}")
-        .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
-        .file("bar/src/lib.rs", "")
+        .file(
+            "build.rs",
+            r#"
+            use std::fs;
+
+            fn main() {
+                fs::write("src/generated.txt",
+                    "Hello, world of generated files."
+                ).expect("failed to create file");
+            }
+        "#,
+        )
         .build();
 
     p.cargo("package --list")
@@ -1830,6 +1849,7 @@ fn list_with_path_and_lock() {
 Cargo.lock
 Cargo.toml
 Cargo.toml.orig
+build.rs
 src/main.rs
 ",
         )
@@ -1837,11 +1857,16 @@ src/main.rs
 
     p.cargo("package")
         .with_status(101)
-        .with_stderr(
+        .with_stderr_contains(
             "\
-error: all path dependencies must have a version specified when packaging.
-dependency `bar` does not specify a version.
-",
+error: failed to verify package tarball
+
+Caused by:
+  Source directory was modified by build.rs during cargo publish. \
+  Build scripts should not modify anything outside of OUT_DIR.
+  Added: [CWD]/target/package/foo-0.1.0/src/generated.txt
+
+  To proceed despite this, pass the `--no-verify` flag.",
         )
         .run();
 }
diff --git a/tests/testsuite/path.rs b/tests/testsuite/path.rs
index 2c5e598650d..3c0b4008710 100644
--- a/tests/testsuite/path.rs
+++ b/tests/testsuite/path.rs
@@ -511,16 +511,13 @@ fn error_message_for_missing_manifest() {
         .with_status(101)
         .with_stderr(
             "\
-[ERROR] failed to get `bar` as a dependency of package `foo v0.5.0 [..]`
+[ERROR] failed to parse manifest at `[..]/foo/Cargo.toml`
 
 Caused by:
-  failed to load source for dependency `bar`
+  failed to get dependency `bar`
 
 Caused by:
-  Unable to update [CWD]/src/bar
-
-Caused by:
-  failed to read `[..]bar/Cargo.toml`
+  failed to read `[..]/bar/Cargo.toml`
 
 Caused by:
   [..] (os error [..])
@@ -1038,6 +1035,17 @@ fn deep_path_error() {
            "#,
         )
         .file("b/src/lib.rs", "")
+        .file(
+            "c/Cargo.toml",
+            r#"
+            [package]
+            name = "c"
+            version = "0.1.0"
+            [dependencies]
+            d = {path="../d"}
+           "#,
+        )
+        .file("c/src/lib.rs", "")
         .build();
 
     p.cargo("check")
@@ -1055,7 +1063,13 @@ Caused by:
   Unable to update [..]/foo/c
 
 Caused by:
-  failed to read `[..]/foo/c/Cargo.toml`
+  failed to parse manifest at `[..]/foo/c/Cargo.toml`
+
+Caused by:
+  failed to get dependency `d`
+
+Caused by:
+  failed to read `[..]/d/Cargo.toml`
 
 Caused by:
   [..]
diff --git a/tests/testsuite/publish.rs b/tests/testsuite/publish.rs
index 502f13c6bb2..2ccee3490be 100644
--- a/tests/testsuite/publish.rs
+++ b/tests/testsuite/publish.rs
@@ -301,7 +301,7 @@ fn path_dependency_no_version() {
             r#"
             [project]
             name = "foo"
-            version = "0.0.1"
+            version = "0.8.9"
             authors = []
             license = "MIT"
             description = "foo"
@@ -315,18 +315,45 @@ fn path_dependency_no_version() {
         .file("bar/src/lib.rs", "")
         .build();
 
-    p.cargo("publish --token sekrit")
-        .with_status(101)
-        .with_stderr(
-            "\
-[UPDATING] [..] index
-[ERROR] all dependencies must have a version specified when publishing.
-dependency `bar` does not specify a version
-Note: The published dependency will use the version from crates.io,
-the `path` specification will be removed from the dependency declaration.
-",
-        )
-        .run();
+    Package::new("bar", "0.0.1").publish();
+    p.cargo("publish --no-verify --token sekrit").run();
+
+    publish::validate_upload(
+        r#"
+        {
+          "authors": [],
+          "badges": {},
+          "categories": [],
+          "deps": [
+            {
+              "default_features": true,
+              "features": [],
+              "kind": "normal",
+              "name": "bar",
+              "optional": false,
+              "registry": "https://github.com/rust-lang/crates.io-index",
+              "target": null,
+              "version_req": "^0.0.1"
+            }
+          ],
+          "description": "foo",
+          "documentation": null,
+          "features": {},
+          "homepage": null,
+          "keywords": [],
+          "license": "MIT",
+          "license_file": null,
+          "links": null,
+          "name": "foo",
+          "readme": null,
+          "readme_file": null,
+          "repository": null,
+          "vers": "0.8.9"
+          }
+        "#,
+        "foo-0.8.9.crate",
+        &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
+    );
 }
 
 #[cargo_test]
@@ -1277,7 +1304,18 @@ fn publish_dev_dep_no_version() {
           "authors": [],
           "badges": {},
           "categories": [],
-          "deps": [],
+          "deps": [
+            {
+              "default_features": true,
+              "features": [],
+              "kind": "dev",
+              "name": "bar",
+              "optional": false,
+              "registry": "https://github.com/rust-lang/crates.io-index",
+              "target": null,
+              "version_req": "^0.0.1"
+            }
+          ],
           "description": "foo",
           "documentation": "foo",
           "features": {},
@@ -1307,8 +1345,8 @@ homepage = "foo"
 documentation = "foo"
 license = "MIT"
 repository = "foo"
-
-[dev-dependencies]
+[dev-dependencies.bar]
+version = "0.0.1"
 "#,
         )],
     );
diff --git a/tests/testsuite/workspaces.rs b/tests/testsuite/workspaces.rs
index e620c975d18..4d88c33c8c5 100644
--- a/tests/testsuite/workspaces.rs
+++ b/tests/testsuite/workspaces.rs
@@ -1,7 +1,9 @@
 //! Tests for workspaces.
 
 use cargo_test_support::registry::Package;
-use cargo_test_support::{basic_lib_manifest, basic_manifest, git, project, sleep_ms};
+use cargo_test_support::{
+    basic_lib_manifest, basic_manifest, basic_workspace_manifest, git, project, sleep_ms,
+};
 use std::env;
 use std::fs;
 
@@ -21,16 +23,7 @@ fn simple_explicit() {
         "#,
         )
         .file("src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = ".."
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", ".."))
         .file("bar/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -63,16 +56,7 @@ fn simple_explicit_default_members() {
         "#,
         )
         .file("src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = ".."
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", ".."))
         .file("bar/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -261,16 +245,7 @@ fn parent_pointer_works() {
         "#,
         )
         .file("foo/src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = "../foo"
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", "../foo"))
         .file("bar/src/main.rs", "fn main() {}")
         .file("bar/src/lib.rs", "");
     let p = p.build();
@@ -297,16 +272,7 @@ fn same_names_in_workspace() {
         "#,
         )
         .file("src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "foo"
-            version = "0.1.0"
-            authors = []
-            workspace = ".."
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("foo", ".."))
         .file("bar/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -360,16 +326,7 @@ this may be fixable [..]
 #[cargo_test]
 fn invalid_parent_pointer() {
     let p = project()
-        .file(
-            "Cargo.toml",
-            r#"
-            [project]
-            name = "foo"
-            version = "0.1.0"
-            authors = []
-            workspace = "foo"
-        "#,
-        )
+        .file("Cargo.toml", &basic_workspace_manifest("foo", "foo"))
         .file("src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -377,7 +334,10 @@ fn invalid_parent_pointer() {
         .with_status(101)
         .with_stderr(
             "\
-error: failed to read `[..]Cargo.toml`
+error: failed to parse manifest at `[..]Cargo.toml`
+
+Caused by:
+  [..]
 
 Caused by:
   [..]
@@ -483,16 +443,7 @@ error: multiple workspace roots found in the same workspace:
 #[cargo_test]
 fn workspace_isnt_root() {
     let p = project()
-        .file(
-            "Cargo.toml",
-            r#"
-            [project]
-            name = "foo"
-            version = "0.1.0"
-            authors = []
-            workspace = "bar"
-        "#,
-        )
+        .file("Cargo.toml", &basic_workspace_manifest("foo", "bar"))
         .file("src/main.rs", "fn main() {}")
         .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
         .file("bar/src/main.rs", "fn main() {}");
@@ -520,27 +471,9 @@ fn dangling_member() {
         "#,
         )
         .file("src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = "../baz"
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", "../baz"))
         .file("bar/src/main.rs", "fn main() {}")
-        .file(
-            "baz/Cargo.toml",
-            r#"
-            [project]
-            name = "baz"
-            version = "0.1.0"
-            authors = []
-            workspace = "../baz"
-        "#,
-        )
+        .file("baz/Cargo.toml", &basic_workspace_manifest("baz", "../baz"))
         .file("baz/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -559,27 +492,9 @@ actual: [..]
 #[cargo_test]
 fn cycle() {
     let p = project()
-        .file(
-            "Cargo.toml",
-            r#"
-            [project]
-            name = "foo"
-            version = "0.1.0"
-            authors = []
-            workspace = "bar"
-        "#,
-        )
+        .file("Cargo.toml", &basic_workspace_manifest("foo", "bar"))
         .file("src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = ".."
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", ".."))
         .file("bar/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -1345,16 +1260,7 @@ fn relative_path_for_member_works() {
     "#,
         )
         .file("foo/src/main.rs", "fn main() {}")
-        .file(
-            "bar/Cargo.toml",
-            r#"
-        [project]
-        name = "bar"
-        version = "0.1.0"
-        authors = []
-        workspace = "../foo"
-    "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", "../foo"))
         .file("bar/src/main.rs", "fn main() {}");
     let p = p.build();
 
@@ -1456,16 +1362,7 @@ fn test_in_and_out_of_workspace() {
             "foo/src/lib.rs",
             "extern crate bar; pub fn f() { bar::f() }",
         )
-        .file(
-            "bar/Cargo.toml",
-            r#"
-            [project]
-            workspace = "../ws"
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-        "#,
-        )
+        .file("bar/Cargo.toml", &basic_workspace_manifest("bar", "../ws"))
         .file("bar/src/lib.rs", "pub fn f() { }");
     let p = p.build();
 
@@ -1737,24 +1634,12 @@ fn glob_syntax() {
         .file("src/main.rs", "fn main() {}")
         .file(
             "crates/bar/Cargo.toml",
-            r#"
-            [project]
-            name = "bar"
-            version = "0.1.0"
-            authors = []
-            workspace = "../.."
-        "#,
+            &basic_workspace_manifest("bar", "../.."),
         )
         .file("crates/bar/src/main.rs", "fn main() {}")
         .file(
             "crates/baz/Cargo.toml",
-            r#"
-            [project]
-            name = "baz"
-            version = "0.1.0"
-            authors = []
-            workspace = "../.."
-        "#,
+            &basic_workspace_manifest("baz", "../.."),
         )
         .file("crates/baz/src/main.rs", "fn main() {}")
         .file(
@@ -2308,13 +2193,10 @@ fn invalid_missing() {
         .with_status(101)
         .with_stderr(
             "\
-[ERROR] failed to get `x` as a dependency of package `foo v0.1.0 [..]`
-
-Caused by:
-  failed to load source for dependency `x`
+[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
 
 Caused by:
-  Unable to update [..]/foo/x
+  failed to get dependency `x`
 
 Caused by:
   failed to read `[..]foo/x/Cargo.toml`