Allow outputs to declare themselves to use content-based path hashing

Summary:
As discussed in https://fb.workplace.com/groups/buck2dev/posts/3975810866040289/, we tie whether or not we're using content-based path hashing to an output, rather than to an action.

I am using `uses_experimental_content_based_path_hashing` for now because I need people to know it is experimental (right now, if they turn it on it won't work correctly, but I need the option available for tests etc).

Reviewed By: JakobDegen

Differential Revision: D72457376

fbshipit-source-id: f5ac91310b02273791ff23a1dc8e6ae91571a52a

Author: Ian Childs

app/buck2_action_impl/src/context/unsorted.rs

@@ -14,6 +14,7 @@ use buck2_build_api::interpreter::rule_defs::context::AnalysisActions;
 use buck2_build_api::interpreter::rule_defs::digest_config::StarlarkDigestConfig;
 use buck2_build_api::interpreter::rule_defs::transitive_set::FrozenTransitiveSetDefinition;
 use buck2_build_api::interpreter::rule_defs::transitive_set::TransitiveSet;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_execute::execute::request::OutputType;
 use starlark::environment::MethodsBuilder;
 use starlark::eval::Evaluator;
@@ -50,6 +51,7 @@ pub(crate) fn analysis_actions_methods_unsorted(builder: &mut MethodsBuilder) {
         #[starlark(require = pos)] prefix: &str,
         #[starlark(require = pos)] filename: Option<&str>,
         #[starlark(require = named, default = false)] dir: bool,
+        #[starlark(require = named, default = false)] uses_experimental_content_based_path_hashing: bool,
         eval: &mut Evaluator<'v, '_, '_>,
     ) -> starlark::Result<StarlarkDeclaredArtifact> {
         // We take either one or two positional arguments, namely (filename) or (prefix, filename).
@@ -65,11 +67,17 @@ pub(crate) fn analysis_actions_methods_unsorted(builder: &mut MethodsBuilder) {
         } else {
             OutputType::FileOrDirectory
         };
+        let path_resolution_method = if uses_experimental_content_based_path_hashing {
+            BuckOutPathKind::ContentHash
+        } else {
+            BuckOutPathKind::Configuration
+        };
         let artifact = this.state()?.declare_output(
             prefix,
             filename,
             output_type,
             eval.call_stack_top_location(),
+            path_resolution_method,
         )?;
 
         Ok(StarlarkDeclaredArtifact::new(

app/buck2_action_impl/src/context/write.rs

@@ -23,6 +23,7 @@ use buck2_build_api::interpreter::rule_defs::cmd_args::WriteToFileMacroVisitor;
 use buck2_build_api::interpreter::rule_defs::cmd_args::value::CommandLineArg;
 use buck2_build_api::interpreter::rule_defs::context::AnalysisActions;
 use buck2_build_api::interpreter::rule_defs::resolved_macro::ResolvedMacro;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_execute::execute::request::OutputType;
 use dupe::Dupe;
 use either::Either;
@@ -253,6 +254,7 @@ pub(crate) fn analysis_actions_methods_write(methods: &mut MethodsBuilder) {
                     &format!("{}/{}.macro", &macro_directory_path, i),
                     OutputType::File,
                     eval.call_stack_top_location(),
+                    BuckOutPathKind::default(),
                 )?;
                 written_macro_files.insert(macro_file);
             }

app/buck2_build_api/src/actions/registry.rs

@@ -20,6 +20,7 @@ use buck2_artifact::artifact::build_artifact::BuildArtifact;
 use buck2_core::category::Category;
 use buck2_core::deferred::key::DeferredHolderKey;
 use buck2_core::execution_types::execution::ExecutionPlatformResolution;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_core::fs::buck_out_path::BuildArtifactPath;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePath;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePathBuf;
@@ -167,13 +168,18 @@ impl ActionsRegistry {
         path: ForwardRelativePathBuf,
         output_type: OutputType,
         declaration_location: Option<FileSpan>,
+        path_resolution_method: BuckOutPathKind,
     ) -> buck2_error::Result<DeclaredArtifact> {
         let (path, hidden) = match prefix {
             None => (path, 0),
             Some(prefix) => (prefix.join(path), prefix.iter().count()),
         };
         self.claim_output_path(&path, declaration_location)?;
-        let out_path = BuildArtifactPath::with_dynamic_actions_action_key(self.owner.dupe(), path);
+        let out_path = BuildArtifactPath::with_dynamic_actions_action_key(
+            self.owner.dupe(),
+            path,
+            path_resolution_method,
+        );
         let declared = DeclaredArtifact::new(out_path, output_type, hidden);
         if !self.artifacts.insert(declared.dupe()) {
             panic!("not expected duplicate artifact after output path was successfully claimed");

app/buck2_build_api/src/analysis/registry.rs

@@ -22,6 +22,7 @@ use buck2_artifact::artifact::build_artifact::BuildArtifact;
 use buck2_core::deferred::base_deferred_key::BaseDeferredKey;
 use buck2_core::deferred::key::DeferredHolderKey;
 use buck2_core::execution_types::execution::ExecutionPlatformResolution;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePath;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePathBuf;
 use buck2_error::BuckErrorContext;
@@ -148,6 +149,7 @@ impl<'v> AnalysisRegistry<'v> {
         filename: &str,
         output_type: OutputType,
         declaration_location: Option<FileSpan>,
+        path_resolution_method: BuckOutPathKind,
     ) -> buck2_error::Result<DeclaredArtifact> {
         // We don't allow declaring `` as an output, although technically there's nothing preventing
         // that
@@ -160,8 +162,13 @@ impl<'v> AnalysisRegistry<'v> {
             None => None,
             Some(x) => Some(ForwardRelativePath::new(x)?.to_owned()),
         };
-        self.actions
-            .declare_artifact(prefix, path, output_type, declaration_location)
+        self.actions.declare_artifact(
+            prefix,
+            path,
+            output_type,
+            declaration_location,
+            path_resolution_method,
+        )
     }
 
     /// Takes a string or artifact/output artifact and converts it into an output artifact
@@ -186,8 +193,13 @@ impl<'v> AnalysisRegistry<'v> {
         let heap = eval.heap();
         let declared_artifact = match value {
             OutputArtifactArg::Str(path) => {
-                let artifact =
-                    self.declare_output(None, path, output_type, declaration_location.dupe())?;
+                let artifact = self.declare_output(
+                    None,
+                    path,
+                    output_type,
+                    declaration_location.dupe(),
+                    BuckOutPathKind::default(),
+                )?;
                 heap.alloc_typed(StarlarkDeclaredArtifact::new(
                     declaration_location,
                     artifact,

app/buck2_build_api_tests/src/actions/registry.rs

@@ -24,6 +24,7 @@ use buck2_core::deferred::key::DeferredHolderKey;
 use buck2_core::execution_types::execution::ExecutionPlatform;
 use buck2_core::execution_types::execution::ExecutionPlatformResolution;
 use buck2_core::execution_types::executor_config::CommandExecutorConfig;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_core::fs::buck_out_path::BuildArtifactPath;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePathBuf;
 use buck2_core::target::configured_target_label::ConfiguredTargetLabel;
@@ -46,20 +47,38 @@ fn declaring_artifacts() -> anyhow::Result<()> {
     );
     let out1 = ForwardRelativePathBuf::unchecked_new("bar.out".into());
     let buckout1 = BuildArtifactPath::new(base.dupe(), out1.clone());
-    let declared1 = actions.declare_artifact(None, out1.clone(), OutputType::File, None)?;
+    let declared1 = actions.declare_artifact(
+        None,
+        out1.clone(),
+        OutputType::File,
+        None,
+        BuckOutPathKind::default(),
+    )?;
     declared1
         .get_path()
         .with_full_path(|p| assert_eq!(p, buckout1.path()));
 
     let out2 = ForwardRelativePathBuf::unchecked_new("bar2.out".into());
     let buckout2 = BuildArtifactPath::new(base, out2.clone());
-    let declared2 = actions.declare_artifact(None, out2, OutputType::File, None)?;
+    let declared2 = actions.declare_artifact(
+        None,
+        out2,
+        OutputType::File,
+        None,
+        BuckOutPathKind::default(),
+    )?;
     declared2
         .get_path()
         .with_full_path(|p| assert_eq!(p, buckout2.path()));
 
     if actions
-        .declare_artifact(None, out1, OutputType::File, None)
+        .declare_artifact(
+            None,
+            out1,
+            OutputType::File,
+            None,
+            BuckOutPathKind::default(),
+        )
         .is_ok()
     {
         panic!("should error due to duplicate artifact")
@@ -129,7 +148,13 @@ fn register_actions() -> anyhow::Result<()> {
         ExecutionPlatformResolution::unspecified(),
     );
     let out = ForwardRelativePathBuf::unchecked_new("bar.out".into());
-    let declared = actions.declare_artifact(None, out, OutputType::File, None)?;
+    let declared = actions.declare_artifact(
+        None,
+        out,
+        OutputType::File,
+        None,
+        BuckOutPathKind::default(),
+    )?;
 
     let inputs = indexset![ArtifactGroup::Artifact(
         BuildArtifact::testing_new(
@@ -177,7 +202,13 @@ fn finalizing_actions() -> anyhow::Result<()> {
         ),
     );
     let out = ForwardRelativePathBuf::unchecked_new("bar.out".into());
-    let declared = actions.declare_artifact(None, out, OutputType::File, None)?;
+    let declared = actions.declare_artifact(
+        None,
+        out,
+        OutputType::File,
+        None,
+        BuckOutPathKind::default(),
+    )?;
 
     let inputs = indexset![ArtifactGroup::Artifact(
         BuildArtifact::testing_new(

app/buck2_build_api_tests/src/interpreter/rule_defs/artifact/testing.rs

@@ -30,6 +30,7 @@ use buck2_core::deferred::key::DeferredHolderKey;
 use buck2_core::execution_types::execution::ExecutionPlatformResolution;
 use buck2_core::execution_types::executor_config::PathSeparatorKind;
 use buck2_core::fs::artifact_path_resolver::ArtifactFs;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_core::fs::buck_out_path::BuckOutPathResolver;
 use buck2_core::fs::paths::abs_norm_path::AbsNormPathBuf;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePathBuf;
@@ -115,6 +116,7 @@ pub(crate) fn artifactory(builder: &mut GlobalsBuilder) {
             ForwardRelativePathBuf::try_from(path.to_owned()).unwrap(),
             OutputType::File,
             None,
+            BuckOutPathKind::default(),
         )?;
         Ok(StarlarkDeclaredArtifact::new(
             None,
@@ -138,6 +140,7 @@ pub(crate) fn artifactory(builder: &mut GlobalsBuilder) {
             ForwardRelativePathBuf::try_from(path.to_owned()).unwrap(),
             OutputType::File,
             None,
+            BuckOutPathKind::default(),
         )?;
         let outputs = indexset![artifact.as_output()];
         registry.register(

app/buck2_core/src/fs/buck_out_path.rs

@@ -99,17 +99,22 @@ pub struct BuildArtifactPath(Arc<BuildArtifactPathData>);
 
 impl BuildArtifactPath {
     pub fn new(owner: BaseDeferredKey, path: ForwardRelativePathBuf) -> Self {
-        Self::with_dynamic_actions_action_key(DeferredHolderKey::Base(owner), path)
+        Self::with_dynamic_actions_action_key(
+            DeferredHolderKey::Base(owner),
+            path,
+            BuckOutPathKind::default(),
+        )
     }
 
     pub fn with_dynamic_actions_action_key(
         owner: DeferredHolderKey,
         path: ForwardRelativePathBuf,
+        path_resolution_method: BuckOutPathKind,
     ) -> Self {
         BuildArtifactPath(Arc::new(BuildArtifactPathData {
             owner,
             path: path.into_box(),
-            path_resolution_method: BuckOutPathKind::Configuration,
+            path_resolution_method,
         }))
     }
 
@@ -411,6 +416,7 @@ mod tests {
     use crate::deferred::dynamic::DynamicLambdaResultsKey;
     use crate::deferred::key::DeferredHolderKey;
     use crate::fs::artifact_path_resolver::ArtifactFs;
+    use crate::fs::buck_out_path::BuckOutPathKind;
     use crate::fs::buck_out_path::BuckOutPathResolver;
     use crate::fs::buck_out_path::BuckOutScratchPath;
     use crate::fs::buck_out_path::BuildArtifactPath;
@@ -552,6 +558,7 @@ mod tests {
                 DynamicLambdaIndex::new(17),
             ))),
             ForwardRelativePathBuf::unchecked_new("quux".to_owned()),
+            BuckOutPathKind::Configuration,
         );
         let resolved_gen_path = path_resolver.resolve_gen(&path)?;