config related fixes after aptos deps version bump

Author: ctoyan

move-mutation-test/src/cli.rs

@@ -2,10 +2,10 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos::{common::types::MovePackageDir, move_tool::experiments_from_opt_level};
+use aptos::common::types::MovePackageOptions;
 use aptos_framework::extended_checks;
 use clap::Parser;
-use move_model::metadata::LanguageVersion;
+use move_model::metadata::{CompilerVersion, LanguageVersion};
 use move_mutator::cli::{FunctionFilter, ModuleFilter};
 use move_package::CompilerConfig;
 use std::path::PathBuf;
@@ -65,27 +65,30 @@ pub fn create_mutator_options(
 // Info: this set struct is based on TestPackage in `aptos-core/crates/aptos/src/move_tool/mod.rs`.
 #[derive(Parser, Debug, Clone)]
 pub struct TestBuildConfig {
-    /// Options for compiling a move package dir.
-    // We might move some options out and have our own option struct here - not all options are
-    // needed for mutation testing.
-    #[clap(flatten)]
-    pub move_pkg: MovePackageDir,
-
-    /// Dump storage state on failure.
-    #[clap(long = "dump")]
-    pub dump_state: bool,
-
-    /// A filter string to determine which unit tests to run.
-    #[clap(long)]
+    /// A filter string to determine which unit tests to run
+    #[clap(long, short)]
     pub filter: Option<String>,
 
     /// A boolean value to skip warnings.
     #[clap(long)]
     pub ignore_compile_warnings: bool,
 
-    /// Compute and then use unit test computed coverage to generate mutants only for covered code.
-    #[clap(long = "coverage", conflicts_with = "use_generated_mutants")]
-    pub apply_coverage: bool,
+    #[clap(flatten)]
+    pub(crate) move_options: MovePackageOptions,
+
+    /// The maximum number of instructions that can be executed by a test
+    ///
+    /// If set, the number of instructions executed by one test will be bounded
+    #[clap(long = "instructions", default_value_t = 100000)]
+    pub instruction_execution_bound: u64,
+
+    /// Collect coverage information for later use with the various `aptos move coverage` subcommands
+    #[clap(long = "coverage")]
+    pub compute_coverage: bool,
+
+    /// Dump storage state on failure.
+    #[clap(long = "dump")]
+    pub dump_state: bool,
 
     /// The maximum gas limit for each test.
     ///
@@ -100,25 +103,38 @@ impl TestBuildConfig {
     pub fn compiler_config(&self) -> CompilerConfig {
         let known_attributes = extended_checks::get_all_attribute_names().clone();
         CompilerConfig {
-            known_attributes,
-            skip_attribute_checks: self.move_pkg.skip_attribute_checks,
-            bytecode_version: get_bytecode_version(
-                self.move_pkg.bytecode_version,
-                self.move_pkg.language_version,
+            known_attributes: known_attributes.clone(),
+            skip_attribute_checks: self.move_options.skip_attribute_checks,
+            bytecode_version: fix_bytecode_version(
+                self.move_options.bytecode_version,
+                self.move_options.language_version,
             ),
-            compiler_version: self.move_pkg.compiler_version,
-            language_version: self.move_pkg.language_version,
-            experiments: experiments_from_opt_level(&self.move_pkg.optimize),
+            compiler_version: self
+                .move_options
+                .compiler_version
+                .or_else(|| Some(CompilerVersion::latest_stable())),
+            language_version: self
+                .move_options
+                .language_version
+                .or_else(|| Some(LanguageVersion::latest_stable())),
+            experiments: self.move_options.compute_experiments(),
         }
     }
 }
 
-/// Get bytecode version.
-fn get_bytecode_version(
+fn fix_bytecode_version(
     bytecode_version_in: Option<u32>,
     language_version: Option<LanguageVersion>,
 ) -> Option<u32> {
-    bytecode_version_in.or_else(|| language_version.map(|lv| lv.infer_bytecode_version(None)))
+    if bytecode_version_in.is_none() {
+        if let Some(language_version) = language_version {
+            Some(language_version.infer_bytecode_version(bytecode_version_in))
+        } else {
+            bytecode_version_in
+        }
+    } else {
+        bytecode_version_in
+    }
 }
 
 #[cfg(test)]

move-mutation-test/src/lib.rs

@@ -52,7 +52,10 @@ pub fn run_mutation_test(
     let _ = pretty_env_logger::try_init();
 
     // Setup output dir and clone package path there.
-    let original_package_path = test_config.move_pkg.get_package_path()?.canonicalize()?;
+    let original_package_path = test_config
+        .move_options
+        .get_package_path()?
+        .canonicalize()?;
     let (outdir, package_path) = setup_outdir_and_package_path(&original_package_path)?;
 
     info!("Running tool the following options: {options:?} and test config: {test_config:?}");
@@ -74,17 +77,17 @@ pub fn run_mutation_test(
     } else {
         benchmarks.mutator.start();
         let mutator_config = BuildConfig {
-            dev_mode: test_config.move_pkg.dev,
-            additional_named_addresses: test_config.move_pkg.named_addresses(),
-            full_model_generation: test_config.move_pkg.check_test_code,
+            dev_mode: test_config.move_options.dev,
+            additional_named_addresses: test_config.move_options.named_addresses(),
+            full_model_generation: test_config.move_options.skip_checks_on_test_code,
             // No need to fetch latest deps again.
             skip_fetch_latest_git_deps: true,
             compiler_config: test_config.compiler_config(),
             ..Default::default()
         };
         let outdir_mutant = run_mutator(
             options,
-            test_config.apply_coverage,
+            test_config.compute_coverage,
             &mutator_config,
             &package_path,
             &outdir,

move-mutation-test/src/mutation_test.rs

@@ -88,9 +88,9 @@ pub(crate) fn run_tests_on_mutated_code(
 
     // Do not calculate the coverage on mutants.
     let mut test_config = cfg.clone();
-    test_config.apply_coverage = false;
+    test_config.compute_coverage = false;
     test_config.ignore_compile_warnings = true;
-    test_config.move_pkg.skip_attribute_checks = true;
+    test_config.move_options.skip_attribute_checks = true;
 
     // Rayon pool will utilize all CPU threads anyway, so one test thread per the bigger rayon
     // thread should be more than enough. Using more threads here slows the overall time.
@@ -118,11 +118,11 @@ fn run_tests<W: WriteColor + Send>(
     mut error_writer: &mut W,
 ) -> anyhow::Result<()> {
     let config = BuildConfig {
-        dev_mode: cfg.move_pkg.dev,
-        additional_named_addresses: cfg.move_pkg.named_addresses(),
+        dev_mode: cfg.move_options.dev,
+        additional_named_addresses: cfg.move_options.named_addresses(),
         test_mode: true,
-        full_model_generation: cfg.move_pkg.check_test_code,
-        install_dir: cfg.move_pkg.output_dir.clone(),
+        full_model_generation: cfg.move_options.skip_checks_on_test_code,
+        install_dir: cfg.move_options.output_dir.clone(),
         skip_fetch_latest_git_deps,
         compiler_config: cfg.compiler_config(),
         ..Default::default()
@@ -144,7 +144,7 @@ fn run_tests<W: WriteColor + Send>(
             report_statistics,
             num_threads,
             named_address_values: cfg
-                .move_pkg
+                .move_options
                 .named_addresses()
                 .iter()
                 .map(|(name, account_address)| {
@@ -173,7 +173,7 @@ fn run_tests<W: WriteColor + Send>(
     )
     .map_err(|err| Error::msg(format!("failed to run unit tests: {err:#}")))?;
 
-    if cfg.apply_coverage {
+    if cfg.compute_coverage {
         // Disk space optimization:
         let trace_path = package_path.join(".trace");
         // Our tool doesn't use the .trace file at all, only the .coverage_map.mvcov file, and