fix: respect lockfile on mise install

e2e/lockfile/test_lockfile_install

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+export MISE_LOCKFILE=1
+export MISE_EXPERIMENTAL=1
+
+mise use tiny@1
+cat <<EOF > .mise.lock
+[tools]
+tiny = "1.0.0"
+EOF
+rm -rf "$MISE_DATA_DIR/installs/tiny"
+mise install
+assert "mise ls tiny --json --current | jq -r '.[0].requested_version'" "1"
+assert "mise ls tiny --json --current | jq -r '.[0].version'" "1.0.0"

src/cli/exec.rs

@@ -62,7 +62,7 @@ impl Exec {
             force: false,
             jobs: self.jobs,
             raw: self.raw,
-            latest_versions: false,
+            resolve_options: Default::default(),
         };
         ts.install_arg_versions(&config, &opts)?;
         ts.notify_if_versions_missing();

src/cli/install.rs

@@ -1,7 +1,9 @@
 use crate::cli::args::{BackendArg, ToolArg};
 use crate::config::Config;
 use crate::lockfile;
-use crate::toolset::{InstallOptions, ToolRequest, ToolSource, ToolVersion, Toolset};
+use crate::toolset::{
+    InstallOptions, ResolveOptions, ToolRequest, ToolSource, ToolVersion, Toolset,
+};
 use crate::ui::multi_progress_report::MultiProgressReport;
 use eyre::{Result, WrapErr};
 use itertools::Itertools;
@@ -75,7 +77,10 @@ impl Install {
             force: self.force,
             jobs: self.jobs,
             raw: self.raw,
-            latest_versions: true,
+            resolve_options: ResolveOptions {
+                use_locked_version: true,
+                latest_versions: true,
+            },
         }
     }
 

src/cli/shell.rs

@@ -48,7 +48,7 @@ impl Shell {
             force: false,
             jobs: self.jobs,
             raw: self.raw,
-            latest_versions: false,
+            resolve_options: Default::default(),
         };
         ts.install_arg_versions(&config, &opts)?;
         ts.notify_if_versions_missing();

src/cli/uninstall.rs

@@ -112,7 +112,10 @@ impl Uninstall {
                     })
                     .collect::<Result<Vec<_>>>()?;
                 if let Some(tvr) = &a.tvr {
-                    tvs.push((tool.clone(), tvr.resolve(tool.as_ref(), false)?));
+                    tvs.push((
+                        tool.clone(),
+                        tvr.resolve(tool.as_ref(), &Default::default())?,
+                    ));
                 }
                 if tvs.is_empty() {
                     warn!("no versions found for {}", style(&tool).blue().for_stderr());

src/cli/upgrade.rs

@@ -1,7 +1,7 @@
 use crate::cli::args::ToolArg;
 use crate::config::{config_file, Config};
 use crate::file::display_path;
-use crate::toolset::{InstallOptions, OutdatedInfo, ToolVersion, ToolsetBuilder};
+use crate::toolset::{InstallOptions, OutdatedInfo, ResolveOptions, ToolVersion, ToolsetBuilder};
 use crate::ui::multi_progress_report::MultiProgressReport;
 use crate::ui::progress_report::SingleReport;
 use crate::{lockfile, runtime_symlinks, shims, ui};
@@ -141,7 +141,10 @@ impl Upgrade {
             force: false,
             jobs: self.jobs,
             raw: self.raw,
-            latest_versions: true,
+            resolve_options: ResolveOptions {
+                use_locked_version: false,
+                latest_versions: true,
+            },
         };
         let new_versions = outdated.iter().map(|o| o.tool_request.clone()).collect();
         let versions = ts.install_versions(config, new_versions, &mpr, &opts)?;

src/cli/use.rs

@@ -105,7 +105,7 @@ impl Use {
                 force: self.force,
                 jobs: self.jobs,
                 raw: self.raw,
-                latest_versions: false,
+                resolve_options: Default::default(),
             },
         )?;
 

src/cli/where.rs

@@ -46,7 +46,7 @@ impl Where {
 
         let ba = tvr.backend();
         let backend = backend::get(ba);
-        let tv = tvr.resolve(backend.as_ref(), false)?;
+        let tv = tvr.resolve(backend.as_ref(), &Default::default())?;
 
         if backend.is_version_installed(&tv, true) {
             miseprintln!("{}", tv.install_path().to_string_lossy());

src/config/config_file/mod.rs

@@ -120,7 +120,7 @@ impl dyn ConfigFile {
                 .map(|tvr| {
                     if pin {
                         let plugin = backend::get(&fa);
-                        let tv = tvr.resolve(plugin.as_ref(), false)?;
+                        let tv = tvr.resolve(plugin.as_ref(), &Default::default())?;
                         Ok(tv.version)
                     } else {
                         Ok(tvr.version())

src/toolset/mod.rs

@@ -27,7 +27,7 @@ use tabled::Tabled;
 pub use tool_request::ToolRequest;
 pub use tool_request_set::{ToolRequestSet, ToolRequestSetBuilder};
 pub use tool_source::ToolSource;
-pub use tool_version::ToolVersion;
+pub use tool_version::{ResolveOptions, ToolVersion};
 pub use tool_version_list::ToolVersionList;
 use versions::{Version, Versioning};
 use xx::regex;
@@ -58,7 +58,7 @@ pub struct InstallOptions {
     pub force: bool,
     pub jobs: Option<usize>,
     pub raw: bool,
-    pub latest_versions: bool,
+    pub resolve_options: ResolveOptions,
 }
 
 impl InstallOptions {
@@ -118,7 +118,7 @@ impl Toolset {
             .iter_mut()
             .collect::<Vec<_>>()
             .par_iter_mut()
-            .map(|(_, v)| v.resolve(false))
+            .map(|(_, v)| v.resolve(&Default::default()))
             .filter(|r| r.is_err())
             .map(|r| r.unwrap_err())
             .collect::<Vec<_>>();
@@ -225,7 +225,7 @@ impl Toolset {
                                         sleep(Duration::from_millis(100));
                                     }
                                 }
-                                let tv = tr.resolve(t.as_ref(), opts.latest_versions)?;
+                                let tv = tr.resolve(t.as_ref(), &opts.resolve_options)?;
                                 let ctx = InstallContext {
                                     ts,
                                     pr: mpr.add(&tv.style()),
@@ -284,7 +284,7 @@ impl Toolset {
                             Some((p, tv)) => Ok((p.clone(), tv.clone())),
                             None => {
                                 let tv = ToolRequest::new(p.fa().clone(), &v, ToolSource::Unknown)?
-                                    .resolve(p.as_ref(), false)
+                                    .resolve(p.as_ref(), &Default::default())
                                     .unwrap();
                                 Ok((p.clone(), tv))
                             }

src/toolset/tool_request.rs

@@ -8,6 +8,7 @@ use xx::file;
 use crate::backend::Backend;
 use crate::cli::args::BackendArg;
 use crate::runtime_symlinks::is_runtime_symlink;
+use crate::toolset::tool_version::ResolveOptions;
 use crate::toolset::{ToolSource, ToolVersion, ToolVersionOptions};
 use crate::{backend, lockfile};
 
@@ -225,8 +226,8 @@ impl ToolRequest {
         Ok(None)
     }
 
-    pub fn resolve(&self, plugin: &dyn Backend, latest_versions: bool) -> Result<ToolVersion> {
-        ToolVersion::resolve(plugin, self.clone(), latest_versions)
+    pub fn resolve(&self, plugin: &dyn Backend, opts: &ResolveOptions) -> Result<ToolVersion> {
+        ToolVersion::resolve(plugin, self.clone(), opts)
     }
 }
 

src/toolset/tool_version.rs

@@ -37,9 +37,9 @@ impl ToolVersion {
     pub fn resolve(
         backend: &dyn Backend,
         request: ToolRequest,
-        latest_versions: bool,
+        opts: &ResolveOptions,
     ) -> Result<Self> {
-        if !latest_versions {
+        if opts.use_locked_version {
             if let Some(v) = request.lockfile_resolve()? {
                 let tv = Self::new(backend, request.clone(), v);
                 return Ok(tv);
@@ -53,12 +53,12 @@ impl ToolVersion {
         }
         let tv = match request.clone() {
             ToolRequest::Version { version: v, .. } => {
-                Self::resolve_version(backend, request, latest_versions, &v)?
+                Self::resolve_version(backend, request, &v, opts)?
             }
             ToolRequest::Prefix { prefix, .. } => Self::resolve_prefix(backend, request, &prefix)?,
             ToolRequest::Sub {
                 sub, orig_version, ..
-            } => Self::resolve_sub(backend, request, latest_versions, &sub, &orig_version)?,
+            } => Self::resolve_sub(backend, request, &sub, &orig_version, opts)?,
             _ => {
                 let version = request.version();
                 Self::new(backend, request, version)
@@ -101,7 +101,11 @@ impl ToolVersion {
         self.backend.downloads_path.join(self.tv_pathname())
     }
     pub fn latest_version(&self, tool: &dyn Backend) -> Result<String> {
-        let tv = self.request.resolve(tool, true)?;
+        let opts = ResolveOptions {
+            latest_versions: true,
+            use_locked_version: false,
+        };
+        let tv = self.request.resolve(tool, &opts)?;
         // map cargo backend specific prefixes to ref
         let version = match tv.request.version().split_once(':') {
             Some((_ref_type @ ("tag" | "branch" | "rev"), r)) => {
@@ -132,8 +136,8 @@ impl ToolVersion {
     fn resolve_version(
         backend: &dyn Backend,
         request: ToolRequest,
-        latest_versions: bool,
         v: &str,
+        opts: &ResolveOptions,
     ) -> Result<ToolVersion> {
         let config = Config::get();
         let v = config.resolve_alias(backend, v)?;
@@ -155,7 +159,7 @@ impl ToolVersion {
             }
             Some((part, v)) if part.starts_with("sub-") => {
                 let sub = part.split_once('-').unwrap().1;
-                return Self::resolve_sub(backend, request, latest_versions, sub, v);
+                return Self::resolve_sub(backend, request, sub, v, opts);
             }
             _ => (),
         }
@@ -169,7 +173,7 @@ impl ToolVersion {
         }
 
         if v == "latest" {
-            if !latest_versions {
+            if !opts.latest_versions {
                 if let Some(v) = backend.latest_installed_version(None)? {
                     return build(v);
                 }
@@ -178,7 +182,7 @@ impl ToolVersion {
                 return build(v);
             }
         }
-        if !latest_versions {
+        if !opts.latest_versions {
             let matches = backend.list_installed_versions_matching(&v)?;
             if matches.contains(&v) {
                 return build(v);
@@ -198,16 +202,16 @@ impl ToolVersion {
     fn resolve_sub(
         tool: &dyn Backend,
         request: ToolRequest,
-        latest_versions: bool,
         sub: &str,
         v: &str,
+        opts: &ResolveOptions,
     ) -> Result<Self> {
         let v = match v {
             "latest" => tool.latest_version(None)?.unwrap(),
             _ => Config::get().resolve_alias(tool, v)?,
         };
         let v = tool_request::version_sub(&v, sub);
-        Self::resolve_version(tool, request, latest_versions, &v)
+        Self::resolve_version(tool, request, &v, opts)
     }
 
     fn resolve_prefix(tool: &dyn Backend, request: ToolRequest, prefix: &str) -> Result<Self> {
@@ -281,3 +285,18 @@ impl Hash for ToolVersion {
         self.version.hash(state);
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct ResolveOptions {
+    pub latest_versions: bool,
+    pub use_locked_version: bool,
+}
+
+impl Default for ResolveOptions {
+    fn default() -> Self {
+        Self {
+            latest_versions: false,
+            use_locked_version: true,
+        }
+    }
+}

src/toolset/tool_version_list.rs

@@ -2,6 +2,7 @@ use crate::backend;
 use crate::cli::args::BackendArg;
 use crate::errors::Error;
 use crate::toolset::tool_request::ToolRequest;
+use crate::toolset::tool_version::ResolveOptions;
 use crate::toolset::{ToolSource, ToolVersion};
 
 /// represents several versions of a tool for a particular plugin
@@ -22,11 +23,11 @@ impl ToolVersionList {
             source,
         }
     }
-    pub fn resolve(&mut self, latest_versions: bool) -> eyre::Result<()> {
+    pub fn resolve(&mut self, opts: &ResolveOptions) -> eyre::Result<()> {
         self.versions.clear();
         let plugin = backend::get(&self.backend);
         for tvr in &mut self.requests {
-            match tvr.resolve(plugin.as_ref(), latest_versions) {
+            match tvr.resolve(plugin.as_ref(), opts) {
                 Ok(v) => self.versions.push(v),
                 Err(err) => {
                     return Err(Error::FailedToResolveVersion {
@@ -58,7 +59,10 @@ mod tests {
         let mut tvl = ToolVersionList::new(fa.clone(), ToolSource::Argument);
         tvl.requests
             .push(ToolRequest::new(fa, "latest", ToolSource::Argument).unwrap());
-        tvl.resolve(true).unwrap();
+        tvl.resolve(&ResolveOptions{
+            latest_versions: true,
+            use_locked_version: false,
+        }).unwrap();
         assert_eq!(tvl.versions.len(), 1);
     }
 
@@ -72,7 +76,10 @@ mod tests {
         let mut tvl = ToolVersionList::new(fa.clone(), ToolSource::Argument);
         tvl.requests
             .push(ToolRequest::new(fa, "latest", ToolSource::Argument).unwrap());
-        let _ = tvl.resolve(true);
+        let _ = tvl.resolve(&ResolveOptions{
+            latest_versions: true,
+            use_locked_version: false,
+        });
         assert_eq!(tvl.versions.len(), 0);
     }
 }