path: &Path,

source_id: SourceId,

config: &Config,

) -> Result<(EitherManifest, Vec<PathBuf>), ManifestError> {

trace!(

"read_manifest; path={}; source-id={}",

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)

.with_context(|| format!("failed to parse manifest at `{}`", path.display()))

.map_err(|err| ManifestError::new(err, path.into()))

contents: &str,

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)?

};

// Provide a helpful error message for a common user error.

if let Some(package) = toml.get("package").or_else(|| toml.get("project")) {

if let Some(feats) = package.get("cargo-features") {

bail!(

"cargo-features = {} was found in the wrong location: it \

toml::to_string(feats).unwrap()

);

}

}

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 {

warnings.add_warning(format!("unused manifest key: {}", key));

if key == "profiles.debug" {

warnings.add_warning("use `[profile.dev]` to configure debug builds".to_string());

}

}

};

let manifest = Rc::new(manifest);

return if manifest.project.is_some() || manifest.package.is_some() {

let (mut manifest, paths) =

TomlManifest::to_real_manifest(&manifest, source_id, package_root, config)?;

add_unused(manifest.warnings_mut());

if manifest.targets().iter().all(|t| t.is_custom_build()) {

bail!(

"no targets specified in the manifest\n\

)

}

Ok((EitherManifest::Real(manifest), paths))

} else {

let (mut m, paths) =

TomlManifest::to_virtual_manifest(&manifest, source_id, package_root, 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),

}

}

let first_error = match toml.parse() {

Ok(ret) => return Ok(ret),

Err(e) => e,

};

let mut second_parser = toml::de::Deserializer::new(toml);

second_parser.set_require_newline_after_table(false);

if let Ok(ret) = toml::Value::deserialize(&mut second_parser) {

let msg = format!(

"\

file.display()

);

config.shell().warn(&msg)?;

return Ok(ret);

}

let mut third_parser = toml::de::Deserializer::new(toml);

third_parser.set_allow_duplicate_after_longer_table(true);

if let Ok(ret) = toml::Value::deserialize(&mut third_parser) {

let msg = format!(

"\

file.display()

);

config.shell().warn(&msg)?;

return Ok(ret);

}

let first_error = anyhow::Error::from(first_error);

Err(first_error.context("could not parse input as TOML"))

/// In the simple format, only a version is specified, eg.

/// `package = "<version>"`

Simple(String),

/// The simple format is equivalent to a detailed dependency

/// specifying only a version, eg.

/// `package = { version = "<version>" }`

Detailed(DetailedTomlDependency<P>),

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where

D: de::Deserializer<'de>,

{

struct TomlDependencyVisitor<P>(PhantomData<P>);

impl<'de, P: Deserialize<'de>> de::Visitor<'de> for TomlDependencyVisitor<P> {

type Value = TomlDependency<P>;

fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

formatter.write_str(

"a version string like \"0.9.8\" or a \

)

}

fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>

where

E: de::Error,

{

Ok(TomlDependency::Simple(s.to_owned()))

}

fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>

where

V: de::MapAccess<'de>,

{

let mvd = de::value::MapAccessDeserializer::new(map);

DetailedTomlDependency::deserialize(mvd).map(TomlDependency::Detailed)

}

}

deserializer.deserialize_any(TomlDependencyVisitor(PhantomData))

}

fn resolve(&self, _: &Config) -> PathBuf {

self.into()

}

fn resolve(&self, c: &Config) -> PathBuf {

self.resolve_path(c)

}

version: Option<String>,

registry: Option<String>,

/// The URL of the `registry` field.

/// This is an internal implementation detail. When Cargo creates a

/// package, it replaces `registry` with `registry-index` so that the

/// manifest contains the correct URL. All users won't have the same

/// registry names configured, so Cargo can't rely on just the name for

/// crates published by other users.

registry_index: Option<String>,

// `path` is relative to the file it appears in. If that's a `Cargo.toml`, it'll be relative to

// that TOML file, and if it's a `.cargo/config` file, it'll be relative to that file.

path: Option<P>,

git: Option<String>,

branch: Option<String>,

tag: Option<String>,

rev: Option<String>,

features: Option<Vec<String>>,

optional: Option<bool>,

default_features: Option<bool>,

#[serde(rename = "default_features")]

default_features2: Option<bool>,

package: Option<String>,

public: Option<bool>,

fn default() -> Self {

Self {

version: Default::default(),

registry: Default::default(),

registry_index: Default::default(),

path: Default::default(),

git: Default::default(),

branch: Default::default(),

tag: Default::default(),

rev: Default::default(),

features: Default::default(),

optional: Default::default(),

default_features: Default::default(),

default_features2: Default::default(),

package: Default::default(),

public: Default::default(),

}

}

cargo_features: Option<Vec<String>>,

package: Option<Box<TomlProject>>,

project: Option<Box<TomlProject>>,

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, TomlDependency>>,

dev_dependencies: Option<BTreeMap<String, TomlDependency>>,

#[serde(rename = "dev_dependencies")]

dev_dependencies2: Option<BTreeMap<String, TomlDependency>>,

build_dependencies: Option<BTreeMap<String, TomlDependency>>,

#[serde(rename = "build_dependencies")]

build_dependencies2: Option<BTreeMap<String, TomlDependency>>,

features: Option<BTreeMap<InternedString, Vec<InternedString>>>,

target: Option<BTreeMap<String, TomlPlatform>>,

replace: Option<BTreeMap<String, TomlDependency>>,

patch: Option<BTreeMap<String, BTreeMap<String, TomlDependency>>>,

workspace: Option<TomlWorkspace>,

badges: Option<BTreeMap<String, BTreeMap<String, String>>>,

pub fn get_all(&self) -> &BTreeMap<InternedString, TomlProfile> {

&self.0

}

pub fn get(&self, name: &str) -> Option<&TomlProfile> {

self.0.get(name)

}

pub fn validate(&self, features: &Features, warnings: &mut Vec<String>) -> CargoResult<()> {

for (name, profile) in &self.0 {

profile.validate(name, features, warnings)?;

}

Ok(())

}

fn deserialize<D>(d: D) -> Result<TomlOptLevel, D::Error>

where

D: de::Deserializer<'de>,

{

struct Visitor;

impl<'de> de::Visitor<'de> for Visitor {

type Value = TomlOptLevel;

fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

formatter.write_str("an optimization level")

}

fn visit_i64<E>(self, value: i64) -> Result<TomlOptLevel, E>

where

E: de::Error,

{

Ok(TomlOptLevel(value.to_string()))

}

fn visit_str<E>(self, value: &str) -> Result<TomlOptLevel, E>

where

E: de::Error,

{

if value == "s" || value == "z" {

Ok(TomlOptLevel(value.to_string()))

} else {

Err(E::custom(format!(

"must be `0`, `1`, `2`, `3`, `s` or `z`, \

value

)))

}

}

}

d.deserialize_any(Visitor)

}

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where

S: ser::Serializer,

{

match self.0.parse::<u32>() {

Ok(n) => n.serialize(serializer),

Err(_) => self.0.serialize(serializer),

}

}

pub opt_level: Option<TomlOptLevel>,

pub lto: Option<StringOrBool>,

pub codegen_backend: Option<InternedString>,

pub codegen_units: Option<u32>,

pub debug: Option<U32OrBool>,

pub split_debuginfo: Option<String>,

pub debug_assertions: Option<bool>,

pub rpath: Option<bool>,

pub panic: Option<String>,

pub overflow_checks: Option<bool>,

pub incremental: Option<bool>,

pub dir_name: Option<InternedString>,

pub inherits: Option<InternedString>,

pub strip: Option<StringOrBool>,

// These two fields must be last because they are sub-tables, and TOML

// requires all non-tables to be listed first.

pub package: Option<BTreeMap<ProfilePackageSpec, TomlProfile>>,

pub build_override: Option<Box<TomlProfile>>,

fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>

where

S: ser::Serializer,

{

match *self {

ProfilePackageSpec::Spec(ref spec) => spec.serialize(s),

ProfilePackageSpec::All => "*".serialize(s),

}

}

fn deserialize<D>(d: D) -> Result<ProfilePackageSpec, D::Error>

where

D: de::Deserializer<'de>,

{

let string = String::deserialize(d)?;

if string == "*" {

Ok(ProfilePackageSpec::All)

} else {

PackageIdSpec::parse(&string)

.map_err(de::Error::custom)

.map(ProfilePackageSpec::Spec)

}

}

pub fn validate(

&self,

name: &str,

features: &Features,

warnings: &mut Vec<String>,

) -> CargoResult<()> {

if let Some(ref profile) = self.build_override {

features.require(Feature::profile_overrides())?;

profile.validate_override("build-override", features)?;

}

if let Some(ref packages) = self.package {

features.require(Feature::profile_overrides())?;

for profile in packages.values() {

profile.validate_override("package", features)?;

}

}

// Feature gate definition of named profiles

match name {

"dev" | "release" | "bench" | "test" | "doc" => {}

_ => {

features.require(Feature::named_profiles())?;

}

}

// Profile name validation

Self::validate_name(name)?;

// Feature gate on uses of keys related to named profiles

if self.inherits.is_some() {

features.require(Feature::named_profiles())?;

}

if let Some(dir_name) = self.dir_name {

// This is disabled for now, as we would like to stabilize named

// profiles without this, and then decide in the future if it is

// needed. This helps simplify the UI a little.

bail!(

"dir-name=\"{}\" in profile `{}` is not currently allowed, \

dir_name,

name

);

}

// `inherits` validation

if matches!(self.inherits.map(|s| s.as_str()), Some("debug")) {

bail!(

"profile.{}.inherits=\"debug\" should be profile.{}.inherits=\"dev\"",

name,

name

);

}

match name {

"doc" => {

warnings.push("profile `doc` is deprecated and has no effect".to_string());

}

"test" | "bench" => {

if self.panic.is_some() {

warnings.push(format!("`panic` setting is ignored for `{}` profile", name))

}

}

_ => {}

}

if let Some(panic) = &self.panic {

if panic != "unwind" && panic != "abort" {

bail!(

"`panic` setting of `{}` is not a valid setting, \

panic

);

}

}

if self.strip.is_some() {

features.require(Feature::strip())?;

}

if let Some(codegen_backend) = &self.codegen_backend {

features.require(Feature::codegen_backend())?;

if codegen_backend.contains(|c: char| !c.is_ascii_alphanumeric() && c != '_') {

bail!(

"`profile.{}.codegen-backend` setting of `{}` is not a valid backend name.",

name,

codegen_backend,

);

}

}

Ok(())

}

/// Validate dir-names and profile names according to RFC 2678.

pub fn validate_name(name: &str) -> CargoResult<()> {

if let Some(ch) = name

.chars()

.find(|ch| !ch.is_alphanumeric() && *ch != '_' && *ch != '-')

{

bail!(

"invalid character `{}` in profile name `{}`\n\

ch,

name

);

}

const SEE_DOCS: &str = "See https://doc.rust-lang.org/cargo/reference/profiles.html \

let lower_name = name.to_lowercase();

if lower_name == "debug" {

bail!(

"profile name `{}` is reserved\n\

name,

SEE_DOCS

);

}

if lower_name == "build-override" {

bail!(

"profile name `{}` is reserved\n\

name,

SEE_DOCS

);

}

// These are some arbitrary reservations. We have no plans to use

// these, but it seems safer to reserve a few just in case we want to

// add more built-in profiles in the future. We can also uses special

// syntax like cargo:foo if needed. But it is unlikely these will ever

// be used.

if matches!(

lower_name.as_str(),

"build"

| "check"

| "clean"

| "config"

| "fetch"

| "fix"

| "install"

| "metadata"

| "package"

| "publish"

| "report"

| "root"

| "run"

| "rust"

| "rustc"

| "rustdoc"

| "tmp"

| "uninstall"

) || lower_name.starts_with("cargo")

{

bail!(

"profile name `{}` is reserved\n\

name,

SEE_DOCS

);

}

Ok(())

}

fn validate_override(&self, which: &str, features: &Features) -> CargoResult<()> {

if self.package.is_some() {

bail!("package-specific profiles cannot be nested");

}

if self.build_override.is_some() {

bail!("build-override profiles cannot be nested");

}

if self.panic.is_some() {

bail!("`panic` may not be specified in a `{}` profile", which)

}

if self.lto.is_some() {

bail!("`lto` may not be specified in a `{}` profile", which)

}

if self.rpath.is_some() {

bail!("`rpath` may not be specified in a `{}` profile", which)

}

if self.codegen_backend.is_some() {

features.require(Feature::codegen_backend())?;

}

Ok(())

}

/// Overwrite self's values with the given profile.

pub fn merge(&mut self, profile: &TomlProfile) {

if let Some(v) = &profile.opt_level {

self.opt_level = Some(v.clone());

}

if let Some(v) = &profile.lto {

self.lto = Some(v.clone());

}

if let Some(v) = profile.codegen_backend {

self.codegen_backend = Some(v);

}

if let Some(v) = profile.codegen_units {

self.codegen_units = Some(v);

}

if let Some(v) = &profile.debug {

self.debug = Some(v.clone());

}

if let Some(v) = profile.debug_assertions {

self.debug_assertions = Some(v);

}

if let Some(v) = &profile.split_debuginfo {

self.split_debuginfo = Some(v.clone());

}

if let Some(v) = profile.rpath {

self.rpath = Some(v);

}

if let Some(v) = &profile.panic {

self.panic = Some(v.clone());

}

if let Some(v) = profile.overflow_checks {

self.overflow_checks = Some(v);

}

if let Some(v) = profile.incremental {

self.incremental = Some(v);

}

if let Some(other_package) = &profile.package {

match &mut self.package {

Some(self_package) => {

for (spec, other_pkg_profile) in other_package {

match self_package.get_mut(spec) {

Some(p) => p.merge(other_pkg_profile),

None => {

self_package.insert(spec.clone(), other_pkg_profile.clone());

}

}

}

}

None => self.package = Some(other_package.clone()),

}

}

if let Some(other_bo) = &profile.build_override {

match &mut self.build_override {

Some(self_bo) => self_bo.merge(other_bo),

None => self.build_override = Some(other_bo.clone()),

}

}

if let Some(v) = &profile.inherits {

self.inherits = Some(*v);

}

if let Some(v) = &profile.dir_name {

self.dir_name = Some(*v);

}

if let Some(v) = &profile.strip {

self.strip = Some(v.clone());

}

}

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where

D: de::Deserializer<'de>,

{

struct Visitor;

impl<'de> de::Visitor<'de> for Visitor {

type Value = StringOrVec;

fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

formatter.write_str("string or list of strings")

}

fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>

where

E: de::Error,

{

Ok(StringOrVec(vec![s.to_string()]))

}

fn visit_seq<V>(self, v: V) -> Result<Self::Value, V::Error>

where

V: de::SeqAccess<'de>,

{

let seq = de::value::SeqAccessDeserializer::new(v);

Vec::deserialize(seq).map(StringOrVec)

}

}

deserializer.deserialize_any(Visitor)

}

pub fn iter<'a>(&'a self) -> std::slice::Iter<'a, String> {

self.0.iter()

}