`a38177d`

Clarify standalone unavailable artifacts

Authored by

espadonne 1 month ago

SHA: a38177d6dd32c062446dd3d9d77d6f55273cf0aa
Parents: dc213db
Tree: ab3f575

2 changed files

Status	File	+	-
M	`.github/workflows/standalone-bootstrap.yml`	10	0
M	`bench/src/lib.rs`	79	1

.github/workflows/standalone-bootstrap.ymlmodified

            grep "backend_mode: external-driver" introspect.txt
            grep "requested_artifacts: asm, runtime" introspect.txt
 +      - name: Verify external-only linked-only introspect guidance
 +        run: |
 +          if cargo run --manifest-path .bencch-external/Cargo.toml -p afs-tests --bin bencch -- introspect armfortas fixtures/runtime/if_else.f90 --artifact armfortas.ir > linked-only-introspect.txt 2>&1; then
 +            echo "expected linked-only armfortas introspect to fail in external-only build" >&2
 +            exit 1
 +          fi
 +          grep "backend_mode: unavailable" linked-only-introspect.txt
 +          grep "failure_stage: none" linked-only-introspect.txt
 +          grep "requested armfortas.ir" linked-only-introspect.txt
++
        - name: Verify external-only compare
          run: |
            cargo run --manifest-path .bencch-external/Cargo.toml -p afs-tests --bin bencch -- compare fixtures/fake_compilers/match_42_a.sh fixtures/fake_compilers/match_42_b.sh --program fixtures/runtime/if_else.f90 > compare.txt

bench/src/lib.rsmodified

      })
+ }
 +fn requested_linked_armfortas_artifacts(requested: &BTreeSet<ArtifactKey>) -> Vec<String> {
 +    requested
 +        .iter()
 +        .filter_map(|artifact| match artifact {
 +            ArtifactKey::Extra(name) if name.starts_with("armfortas.") => Some(name.clone()),
 +            _ => None,
 +        })
 +        .collect()
 +}
++
  fn observe_compiler(
      spec: &CompilerSpec,
      program: &Path,
      tools: &ToolchainConfig,
  ) -> Result<CompilerObservation, String> {
      let stages = armfortas_requested_stages(requested)?;
 +    let linked_only_artifacts = requested_linked_armfortas_artifacts(requested);
 +    let linked_backend = tools.armfortas_adapters();
 +    if !linked_only_artifacts.is_empty() && linked_backend.capture_mode_name() == "unavailable" {
 +        let detail = format!(
 +            "linked armfortas capture is unavailable in this build; requested {}; use scripts/bootstrap-linked-armfortas.sh or request only asm/obj/run from an external armfortas binary",
 +            linked_only_artifacts.join(", ")
 +        );
 +        return Ok(CompilerObservation {
 +            compiler: CompilerSpec::Named(NamedCompiler::Armfortas),
 +            program: program.to_path_buf(),
 +            opt_level,
 +            compile_exit_code: 1,
 +            artifacts: BTreeMap::from([(
 +                ArtifactKey::Diagnostics,
 +                ArtifactValue::Text(detail.clone()),
 +            )]),
 +            provenance: ObservationProvenance {
 +                compiler_identity: "armfortas".into(),
 +                adapter_kind: "named".into(),
 +                backend_mode: linked_backend.capture_mode_name().into(),
 +                backend_detail: linked_backend.capture_description().into(),
 +                artifacts_captured: vec!["diagnostics".into()],
 +                comparison_basis: None,
 +                failure_stage: None,
 +            },
 +        });
 +    }
      let cli_observable_only = requested.iter().all(|artifact| {
          matches!(
              artifact,
          };
          (mode, detail, backend.capture(&request))
      } else {
 -        let backend = tools.armfortas_adapters();
 +        let backend = linked_backend;
          let detail = backend.capture_description().to_string();
          let mode = backend.capture_mode_name().to_string();
          let request = CaptureRequest {
+ }
  fn compose_observation_failure_detail(observation: &CompilerObservation) -> String {
 +    if observation.provenance.backend_mode == "unavailable" {
 +        let mut detail = format!(
 +            "{} unavailable for requested artifacts in this build",
 +            observation.compiler.display_name()
 +        );
 +        if let Some(diagnostics) = observation_diagnostics_text(observation) {
 +            detail.push('\n');
 +            detail.push_str(diagnostics);
 +        }
 +        return detail;
 +    }
++
      let mut detail = String::new();
      detail.push_str(&format!("{} failed", observation.compiler.display_name()));
      if let Some(stage) = &observation.provenance.failure_stage {
          assert!(rendered.contains("failure_stage: none"));
+     }
 +    #[test]
 +    fn compose_observation_failure_detail_uses_unavailable_wording() {
 +        let observation = CompilerObservation {
 +            compiler: CompilerSpec::Named(NamedCompiler::Armfortas),
 +            program: PathBuf::from("demo.f90"),
 +            opt_level: OptLevel::O0,
 +            compile_exit_code: 1,
 +            artifacts: BTreeMap::from([(
 +                ArtifactKey::Diagnostics,
 +                ArtifactValue::Text(
 +                    "linked armfortas capture is unavailable in this build".into(),
 +                ),
 +            )]),
 +            provenance: ObservationProvenance {
 +                compiler_identity: "armfortas".into(),
 +                adapter_kind: "named".into(),
 +                backend_mode: "unavailable".into(),
 +                backend_detail: "unavailable without linked-armfortas feature".into(),
 +                artifacts_captured: vec!["diagnostics".into()],
 +                comparison_basis: None,
 +                failure_stage: None,
 +            },
 +        };
++
 +        let detail = compose_observation_failure_detail(&observation);
 +        assert!(detail.contains("armfortas unavailable for requested artifacts in this build"));
 +        assert!(!detail.contains("failed in"));
 +    }
++
      #[cfg(unix)]
      #[test]
      fn execute_generic_suite_case_uses_introspect_engine() {