Auto merge of #14368 - epage:beta-vendor, r=weihanglo

[beta-1.81] fix(vendor): Strip excluded build targets

Beta backports

* #14367

In order to make CI pass, the following PRs are also cherry-picked:

* Ignore `build_std::basic` test (see also #14366)
* 830db6f (#14341, see also #14366)

src/cargo/ops/vendor.rs

@@ -221,7 +221,7 @@ fn sync(
  let pathsource = PathSource::new(src, id.source_id(), gctx);
  let paths = pathsource.list_files(pkg)?;
  let mut map = BTreeMap::new();
- cp_sources(pkg, src, &paths, &dst, &mut map, &mut tmp_buf)
+ cp_sources(pkg, src, &paths, &dst, &mut map, &mut tmp_buf, gctx)
  .with_context(|| format!("failed to copy over vendored sources for: {}", id))?;
 
  // Finally, emit the metadata about this package
@@ -317,6 +317,7 @@ fn cp_sources(
  dst: &Path,
  cksums: &mut BTreeMap<String, String>,
  tmp_buf: &mut [u8],
+ gctx: &GlobalContext,
 ) -> CargoResult<()> {
  for p in paths {
  let relative = p.strip_prefix(&src).unwrap();
@@ -360,7 +361,12 @@ fn cp_sources(
  let cksum = if dst.file_name() == Some(OsStr::new("Cargo.toml"))
  && pkg.package_id().source_id().is_git()
  {
- let contents = pkg.manifest().to_resolved_contents()?;
+ let packaged_files = paths
+ .iter()
+ .map(|p| p.strip_prefix(src).unwrap().to_owned())
+ .collect::<Vec<_>>();
+ let vendored_pkg = prepare_for_vendor(pkg, &packaged_files, gctx)?;
+ let contents = vendored_pkg.manifest().to_resolved_contents()?;
  copy_and_checksum(
  &dst,
  &mut dst_opts,
@@ -392,6 +398,116 @@ fn cp_sources(
  Ok(())
 }
 
+/// HACK: Perform the bare minimum of `prepare_for_publish` needed for #14348.
+///
+/// There are parts of `prepare_for_publish` that could be directly useful (e.g. stripping
+/// `[workspace]`) while other parts that require other filesystem operations (moving the README
+/// file) and ideally we'd reuse `cargo package` code to take care of all of this for us.
+fn prepare_for_vendor(
+ me: &Package,
+ packaged_files: &[PathBuf],
+ gctx: &GlobalContext,
+) -> CargoResult<Package> {
+ let contents = me.manifest().contents();
+ let document = me.manifest().document();
+ let original_toml =
+ prepare_toml_for_vendor(me.manifest().resolved_toml().clone(), packaged_files, gctx)?;
+ let normalized_toml = original_toml.clone();
+ let features = me.manifest().unstable_features().clone();
+ let workspace_config = me.manifest().workspace_config().clone();
+ let source_id = me.package_id().source_id();
+ let mut warnings = Default::default();
+ let mut errors = Default::default();
+ let manifest = crate::util::toml::to_real_manifest(
+ contents.to_owned(),
+ document.clone(),
+ original_toml,
+ normalized_toml,
+ features,
+ workspace_config,
+ source_id,
+ me.manifest_path(),
+ gctx,
+ &mut warnings,
+ &mut errors,
+ )?;
+ let new_pkg = Package::new(manifest, me.manifest_path());
+ Ok(new_pkg)
+}
+
+fn prepare_toml_for_vendor(
+ mut me: cargo_util_schemas::manifest::TomlManifest,
+ packaged_files: &[PathBuf],
+ gctx: &GlobalContext,
+) -> CargoResult<cargo_util_schemas::manifest::TomlManifest> {
+ let package = me
+ .package
+ .as_mut()
+ .expect("venedored manifests must have packages");
+ if let Some(cargo_util_schemas::manifest::StringOrBool::String(path)) = &package.build {
+ let path = paths::normalize_path(Path::new(path));
+ let included = packaged_files.contains(&path);
+ let build = if included {
+ let path = path
+ .into_os_string()
+ .into_string()
+ .map_err(|_err| anyhow::format_err!("non-UTF8 `package.build`"))?;
+ let path = crate::util::toml::normalize_path_string_sep(path);
+ cargo_util_schemas::manifest::StringOrBool::String(path)
+ } else {
+ gctx.shell().warn(format!(
+ "ignoring `package.build` as `{}` is not included in the published package",
+ path.display()
+ ))?;
+ cargo_util_schemas::manifest::StringOrBool::Bool(false)
+ };
+ package.build = Some(build);
+ }
+
+ let lib = if let Some(target) = &me.lib {
+ crate::util::toml::prepare_target_for_publish(
+ target,
+ Some(packaged_files),
+ "library",
+ gctx,
+ )?
+ } else {
+ None
+ };
+ let bin = crate::util::toml::prepare_targets_for_publish(
+ me.bin.as_ref(),
+ Some(packaged_files),
+ "binary",
+ gctx,
+ )?;
+ let example = crate::util::toml::prepare_targets_for_publish(
+ me.example.as_ref(),
+ Some(packaged_files),
+ "example",
+ gctx,
+ )?;
+ let test = crate::util::toml::prepare_targets_for_publish(
+ me.test.as_ref(),
+ Some(packaged_files),
+ "test",
+ gctx,
+ )?;
+ let bench = crate::util::toml::prepare_targets_for_publish(
+ me.bench.as_ref(),
+ Some(packaged_files),
+ "benchmark",
+ gctx,
+ )?;
+
+ me.lib = lib;
+ me.bin = bin;
+ me.example = example;
+ me.test = test;
+ me.bench = bench;
+
+ Ok(me)
+}
+
 fn copy_and_checksum<T: Read>(
  dst_path: &Path,
  dst_opts: &mut OpenOptions,

src/cargo/util/toml/mod.rs

@@ -1107,7 +1107,7 @@ fn deprecated_ws_default_features(
 }
 
 #[tracing::instrument(skip_all)]
-fn to_real_manifest(
+pub fn to_real_manifest(
  contents: String,
  document: toml_edit::ImDocument<String>,
  original_toml: manifest::TomlManifest,
@@ -2897,7 +2897,7 @@ fn prepare_toml_for_publish(
  }
 }
 
-fn prepare_targets_for_publish(
+pub fn prepare_targets_for_publish(
  targets: Option<&Vec<manifest::TomlTarget>>,
  included: Option<&[PathBuf]>,
  context: &str,
@@ -2922,7 +2922,7 @@ fn prepare_targets_for_publish(
  }
 }
 
-fn prepare_target_for_publish(
+pub fn prepare_target_for_publish(
  target: &manifest::TomlTarget,
  included: Option<&[PathBuf]>,
  context: &str,
@@ -2957,7 +2957,7 @@ fn normalize_path_sep(path: PathBuf, context: &str) -> CargoResult<PathBuf> {
  Ok(path.into())
 }
 
-fn normalize_path_string_sep(path: String) -> String {
+pub fn normalize_path_string_sep(path: String) -> String {
  if std::path::MAIN_SEPARATOR != '/' {
  path.replace(std::path::MAIN_SEPARATOR, "/")
  } else {

tests/build-std/main.rs

@@ -62,6 +62,8 @@ impl BuildStd for Execs {
  }
 }
 
+#[allow(unused_attributes)]
+#[ignore = "to unblock beta-1.81 backport"]
 #[cargo_test(build_std_real)]
 fn basic() {
  let p = project()

tests/testsuite/check.rs

@@ -820,7 +820,7 @@ fn short_message_format() {
  .with_status(101)
  .with_stderr_data(str![[r#"
 [CHECKING] foo v0.0.1 ([ROOT]/foo)
-src/lib.rs:1:27: error[E0308]: mismatched types
+src/lib.rs:1:27: error[E0308]: mismatched types[..]
 [ERROR] could not compile `foo` (lib) due to 1 previous error
 
 "#]])