move: build writes toolchain version to Move.lock

Cargo.toml

@@ -184,7 +184,7 @@ members = [
 ]
 
 [workspace.package]
-# This version string will be inherited by sui-core, sui-faucet, sui-node, sui-tools, sui-sdk, and sui crates.
+# This version string will be inherited by sui-core, sui-faucet, sui-node, sui-tools, sui-sdk, sui-move-build, and sui crates.
 version = "1.16.0"
 
 [profile.release]

crates/sui-core/src/unit_tests/move_package_publish_tests.rs

@@ -199,8 +199,14 @@ async fn test_generate_lock_file() {
     let mut build_config = BuildConfig::new_for_testing();
     build_config.config.lock_file = Some(lock_file_path.clone());
     build_config
-        .build(path)
+        .clone()
+        .build(path.clone())
         .expect("Move package did not build");
+    // Update the lock file with placeholder compiler version so this isn't bumped every release.
+    build_config
+        .config
+        .update_lock_file_toolchain_version(&path, "0.0.1".into())
+        .expect("Could not update lock file");
 
     let mut lock_file_contents = String::new();
     File::open(lock_file_path)
@@ -240,6 +246,11 @@ async fn test_generate_lock_file() {
         dependencies = [
           { name = "MoveStdlib" },
         ]
+
+        [move.toolchain-version]
+        compiler-version = "0.0.1"
+        edition = "legacy"
+        flavor = "sui"
     "#]];
     expected.assert_eq(lock_file_contents.as_str());
 }

crates/sui-move-build/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sui-move-build"
-version = "0.0.0"
+version.workspace = true
 edition = "2021"
 authors = ["Mysten Labs <eng@mystenlabs.com>"]
 description = "Logic for building Sui Move Packages"

crates/sui-move-build/src/lib.rs

@@ -145,12 +145,23 @@ impl BuildConfig {
         let print_diags_to_stderr = self.print_diags_to_stderr;
         let run_bytecode_verifier = self.run_bytecode_verifier;
         let resolution_graph = self.resolution_graph(&path)?;
-        build_from_resolution_graph(
-            path,
+        let result = build_from_resolution_graph(
+            path.clone(),
             resolution_graph,
             run_bytecode_verifier,
             print_diags_to_stderr,
-        )
+        );
+        if let Ok(ref compiled) = result {
+            compiled
+                .package
+                .compiled_package_info
+                .build_flags
+                .update_lock_file_toolchain_version(&path, env!("CARGO_PKG_VERSION").into())
+                .map_err(|e| SuiError::ModuleBuildFailure {
+                    error: format!("Failed to update Move.lock toolchain version: {e}"),
+                })?;
+        }
+        result
     }
 
     pub fn resolution_graph(mut self, path: &Path) -> SuiResult<ResolvedGraph> {

external-crates/move/crates/move-package/src/lib.rs

@@ -176,6 +176,7 @@ impl BuildConfig {
         let lock_string = std::fs::read_to_string(path.join(SourcePackageLayout::Lock.path())).ok();
         let _mutx = PackageLock::lock(); // held until function returns
 
+        let install_dir_set = self.install_dir.is_some();
         let install_dir = self.install_dir.as_ref().unwrap_or(&path).to_owned();
 
         let mut dep_graph_builder = DependencyGraphBuilder::new(
@@ -190,7 +191,9 @@ impl BuildConfig {
             lock_string,
         )?;
 
-        if modified {
+        if modified || install_dir_set {
+            // (1) Write the Move.lock file if the existing one is `modified`, or
+            // (2) `install_dir` is set explicitly, which may be a different directory, and where a Move.lock does not exist yet.
             let lock = dependency_graph.write_to_lock(install_dir)?;
             if let Some(lock_path) = &self.lock_file {
                 lock.commit(lock_path)?;
@@ -222,14 +225,15 @@ impl BuildConfig {
             .set_silence_warnings(self.silence_warnings)
     }
 
-    pub fn update_lock_file_toolchain_version(&self, compiler_version: String) -> Result<()> {
+    pub fn update_lock_file_toolchain_version(
+        &self,
+        path: &PathBuf,
+        compiler_version: String,
+    ) -> Result<()> {
         let Some(lock_file) = self.lock_file.as_ref() else {
             return Ok(());
         };
-        let install_dir = self
-            .install_dir
-            .clone()
-            .unwrap_or_else(|| PathBuf::from("."));
+        let install_dir = self.install_dir.as_ref().unwrap_or(path).to_owned();
         let mut lock = LockFile::from(install_dir, lock_file)?;
         lock.seek(SeekFrom::Start(0))?;
         update_compiler_toolchain(

external-crates/move/crates/move-package/src/lock_file/schema.rs

@@ -5,7 +5,7 @@
 //! [move] table).  This module does not support serialization because of limitations in the `toml`
 //! crate related to serializing types as inline tables.
 
-use std::io::{Read, Seek, SeekFrom, Write};
+use std::io::{Read, Seek, Write};
 
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
@@ -182,7 +182,6 @@ pub fn update_compiler_toolchain(
 ) -> Result<()> {
     let mut toml_string = String::new();
     file.read_to_string(&mut toml_string)?;
-    file.seek(SeekFrom::Start(0))?;
     let mut toml = toml_string.parse::<toml_edit::Document>()?;
     let move_table = toml["move"].as_table_mut().ok_or(std::fmt::Error)?;
     let toolchain_version = toml::Value::try_from(ToolchainVersion {
@@ -191,6 +190,8 @@ pub fn update_compiler_toolchain(
         flavor,
     })?;
     move_table["toolchain-version"] = to_toml_edit_value(&toolchain_version);
+    file.set_len(0)?;
+    file.rewind()?;
     write!(file, "{}", toml)?;
     file.flush()?;
     Ok(())

external-crates/move/crates/move-package/tests/test_lock_file.rs

@@ -82,7 +82,8 @@ fn update_lock_file_toolchain_version() {
     build_config.default_flavor = Some(Flavor::Sui);
     build_config.default_edition = Some(Edition::E2024_ALPHA);
     build_config.lock_file = Some(lock_path.clone());
-    let _ = build_config.update_lock_file_toolchain_version("0.0.1".into());
+    let _ =
+        build_config.update_lock_file_toolchain_version(&pkg.path().to_path_buf(), "0.0.1".into());
 
     let mut lock_file = File::open(lock_path).unwrap();
     let toolchain_version =