Prevent most fixups (such as rustc_flags) from applying to buildscript

Summary:
In the fixups we use for `coreaudio-sys` and `rustix`, it is very surprising that the `rustc_flags` they specify were getting applied against **both** the library and the library's build script.

https://www.internalfb.com/code/fbsource/[3bec93b51a600700d81b31f6cc00c31af209902f]/third-party/rust/fixups/coreaudio-sys/fixups.toml?lines=3%2C11-17

https://www.internalfb.com/code/fbsource/[3bec93b51a600700d81b31f6cc00c31af209902f]/third-party/rust/fixups/rustix/fixups.toml?lines=3-4

Flags like `-lframework=AudioUnit` and `-Zdefault-visibility=hidden` are definitely intended for the library only.

This diff rearranges Reindeer's processing of fixups for libraries and build scripts to make build scripts only receive fixups pertaining to `srcs` (such as `extra_srcs`), `mapped_srcs` (such as `overlay`), and `features`. Other fixups such as `rustc_flags` and `env` and `link_style` should *not* get applied to the build script.

For `link_style` (since D74046797) and for `env` (since D73977930), it's now possible to control those for the build script build independently of the library.

```lang=toml
# before: applied to both
# now: not build script
rustc_flags = [...]
link_style = "..."
env = {...}

[buildscript.build]
# for build script build
link_style = "..."
env = {...}
# if ever needed, add support for rustc_flags here
```

Reviewed By: JakobDegen

Differential Revision: D74046795

fbshipit-source-id: a6592b7827424c00e5b2683bbc2ef0ed74dda6b3

Author: David Tolnay

src/buckify.rs

@@ -45,7 +45,6 @@ use crate::buck::RuleRef;
 use crate::buck::RustBinary;
 use crate::buck::RustCommon;
 use crate::buck::RustLibrary;
-use crate::buck::Selectable;
 use crate::buck::StringOrPath;
 use crate::buck::SubtargetOrPath;
 use crate::buck::Visibility;
@@ -539,31 +538,6 @@ fn generate_target_rules<'scope>(
     // Per platform rule bits
     let mut perplat: BTreeMap<PlatformName, PlatformRustCommon> = BTreeMap::new();
 
-    unzip_platform(
-        config,
-        &mut base,
-        &mut perplat,
-        |rule, (flags, flags_select)| {
-            log::debug!(
-                "pkg {} target {}: adding flags {:?} and select {:?}",
-                pkg,
-                tgt.name,
-                flags,
-                flags_select
-            );
-            rule.rustc_flags.common.extend(flags);
-            flags_select.into_iter().for_each(|(k, v)| {
-                rule.rustc_flags
-                    .selects
-                    .entry(k)
-                    .or_insert(BTreeSet::new())
-                    .extend(v);
-            });
-        },
-        fixups.compute_cmdline(),
-    )
-    .context("rustc_flags")?;
-
     if matches!(config.vendor, VendorConfig::Source(_)) || matches!(pkg.source, Source::Local) {
         unzip_platform(
             config,
@@ -590,28 +564,6 @@ fn generate_target_rules<'scope>(
             .insert(BuckPath(PathBuf::from(http_archive_target)));
     }
 
-    unzip_platform(
-        config,
-        &mut base,
-        &mut perplat,
-        |rule, ()| {
-            log::debug!(
-                "pkg {} target {}: adding OUT_DIR for gen_srcs",
-                pkg,
-                tgt.name,
-            );
-            rule.env.unwrap_mut().insert(
-                "OUT_DIR".to_owned(),
-                StringOrPath::String(format!(
-                    "$(location :{}[out_dir])",
-                    fixups.buildscript_genrule_name(),
-                )),
-            );
-        },
-        fixups.compute_gen_srcs(),
-    )
-    .context("OUT_DIR for gen_srcs")?;
-
     unzip_platform(
         config,
         &mut base,
@@ -646,18 +598,6 @@ fn generate_target_rules<'scope>(
     )
     .context("features")?;
 
-    unzip_platform(
-        config,
-        &mut base,
-        &mut perplat,
-        |rule, env| {
-            log::debug!("pkg {} target {}: adding env {:?}", pkg, tgt.name, env);
-            rule.env.unwrap_mut().extend(env);
-        },
-        fixups.compute_env()?,
-    )
-    .context("env")?;
-
     // Compute set of dependencies any rule we generate here will need. They will only
     // be emitted if we actually emit some rules below.
     let mut dep_pkgs = Vec::new();
@@ -746,6 +686,90 @@ fn generate_target_rules<'scope>(
         }
     }
 
+    // If this is a build script, we only apply fixups pertaining to srcs
+    // (extra_srcs), mapped_srcs (overlay), and features. Return early before
+    // applying any other fixups (such as rustc_flags, env, or link_style).
+    // Every other fixup handled after this point should only apply to the
+    // library or binary, not a build script.
+    if tgt.crate_bin() && tgt.kind_custom_build() {
+        let buildscript = RustBinary {
+            common: RustCommon {
+                common: Common {
+                    name: Name(format!("{}-{}", pkg, tgt.name)),
+                    visibility: Visibility::Private,
+                    licenses: Default::default(),
+                    compatible_with: vec![],
+                },
+                krate: tgt.name.replace('-', "_"),
+                crate_root: BuckPath(crate_root),
+                edition,
+                base,
+                platform: perplat,
+            },
+        };
+        let rules = fixups.emit_buildscript_rules(buildscript, config, manifest_dir_subtarget)?;
+        return Ok((rules, dep_pkgs));
+    }
+
+    unzip_platform(
+        config,
+        &mut base,
+        &mut perplat,
+        |rule, (flags, flags_select)| {
+            log::debug!(
+                "pkg {} target {}: adding flags {:?} and select {:?}",
+                pkg,
+                tgt.name,
+                flags,
+                flags_select
+            );
+            rule.rustc_flags.common.extend(flags);
+            flags_select.into_iter().for_each(|(k, v)| {
+                rule.rustc_flags
+                    .selects
+                    .entry(k)
+                    .or_insert(BTreeSet::new())
+                    .extend(v);
+            });
+        },
+        fixups.compute_cmdline(),
+    )
+    .context("rustc_flags")?;
+
+    unzip_platform(
+        config,
+        &mut base,
+        &mut perplat,
+        |rule, ()| {
+            log::debug!(
+                "pkg {} target {}: adding OUT_DIR for gen_srcs",
+                pkg,
+                tgt.name,
+            );
+            rule.env.unwrap_mut().insert(
+                "OUT_DIR".to_owned(),
+                StringOrPath::String(format!(
+                    "$(location :{}[out_dir])",
+                    fixups.buildscript_genrule_name(),
+                )),
+            );
+        },
+        fixups.compute_gen_srcs(),
+    )
+    .context("OUT_DIR for gen_srcs")?;
+
+    unzip_platform(
+        config,
+        &mut base,
+        &mut perplat,
+        |rule, env| {
+            log::debug!("pkg {} target {}: adding env {:?}", pkg, tgt.name, env);
+            rule.env.unwrap_mut().extend(env);
+        },
+        fixups.compute_env()?,
+    )
+    .context("env")?;
+
     // "link_style" only really applies to binaries, so maintain separate binary base & perplat
     let mut bin_base = base.clone();
     let mut bin_perplat = perplat.clone();
@@ -877,30 +901,6 @@ fn generate_target_rules<'scope>(
         dep_pkgs.push((pkg, TargetReq::BuildScript));
 
         rules
-    } else if tgt.crate_bin() && tgt.kind_custom_build() {
-        // Build script
-        let buildscript = RustBinary {
-            common: RustCommon {
-                common: Common {
-                    name: Name(format!("{}-{}", pkg, tgt.name)),
-                    visibility: Visibility::Private,
-                    licenses: Default::default(),
-                    compatible_with: vec![],
-                },
-                krate: tgt.name.replace('-', "_"),
-                crate_root: BuckPath(crate_root),
-                edition,
-                base: PlatformRustCommon {
-                    // don't use fixed ones because it will be a cyclic dependency
-                    rustc_flags: Default::default(),
-                    env: Selectable::default(),
-                    link_style: None,
-                    ..base
-                },
-                platform: bin_perplat,
-            },
-        };
-        fixups.emit_buildscript_rules(buildscript, config, manifest_dir_subtarget)?
     } else if tgt.kind_bin() && tgt.crate_bin() {
         let mut rules = vec![];
         let actual = Name(format!("{}-{}", index.private_rule_name(pkg), tgt.name));