refactor: Clarify some variable names

Author: epage

src/cargo/ops/cargo_add/mod.rs

@@ -702,11 +702,16 @@ ignoring {dependency}@{latest_version} (which requires rustc {latest_rust_versio
 /// - `msrvs` is sorted by version
 fn latest_compatible<'s>(
     msrvs: &[(&'s Summary, Option<&RustVersion>)],
-    req_msrv: &RustVersion,
+    pkg_msrv: &RustVersion,
 ) -> Option<&'s Summary> {
     msrvs
         .iter()
-        .filter(|(_, v)| v.as_ref().map(|msrv| req_msrv >= *msrv).unwrap_or(true))
+        .filter(|(_, dep_msrv)| {
+            dep_msrv
+                .as_ref()
+                .map(|dep_msrv| pkg_msrv >= *dep_msrv)
+                .unwrap_or(true)
+        })
         .map(|(s, _)| s)
         .last()
         .copied()

src/cargo/ops/cargo_compile/mod.rs

@@ -481,34 +481,34 @@ pub fn create_bcx<'a, 'gctx>(
 
     if honor_rust_version {
         // Remove any pre-release identifiers for easier comparison
-        let current_version = &target_data.rustc.version;
-        let untagged_version = semver::Version::new(
-            current_version.major,
-            current_version.minor,
-            current_version.patch,
+        let rustc_version = &target_data.rustc.version;
+        let rustc_version_untagged = semver::Version::new(
+            rustc_version.major,
+            rustc_version.minor,
+            rustc_version.patch,
         );
 
         let mut incompatible = Vec::new();
         let mut local_incompatible = false;
         for unit in unit_graph.keys() {
-            let Some(version) = unit.pkg.rust_version() else {
+            let Some(pkg_msrv) = unit.pkg.rust_version() else {
                 continue;
             };
 
-            let req = version.to_caret_req();
-            if req.matches(&untagged_version) {
+            let pkg_msrv_req = pkg_msrv.to_caret_req();
+            if pkg_msrv_req.matches(&rustc_version_untagged) {
                 continue;
             }
 
             local_incompatible |= unit.is_local();
-            incompatible.push((unit, version));
+            incompatible.push((unit, pkg_msrv));
         }
         if !incompatible.is_empty() {
             use std::fmt::Write as _;
 
             let plural = if incompatible.len() == 1 { "" } else { "s" };
             let mut message = format!(
-                "rustc {current_version} is not supported by the following package{plural}:\n"
+                "rustc {rustc_version} is not supported by the following package{plural}:\n"
             );
             incompatible.sort_by_key(|(unit, _)| (unit.pkg.name(), unit.pkg.version()));
             for (unit, msrv) in incompatible {
@@ -529,7 +529,7 @@ pub fn create_bcx<'a, 'gctx>(
                     &mut message,
                     "Either upgrade rustc or select compatible dependency versions with
 `cargo update <name>@<current-ver> --precise <compatible-ver>`
-where `<compatible-ver>` is the latest version supporting rustc {current_version}",
+where `<compatible-ver>` is the latest version supporting rustc {rustc_version}",
                 )
                 .unwrap();
             }

src/cargo/util/toml/mod.rs

@@ -580,32 +580,32 @@ pub fn to_real_manifest(
             .parse()
             .with_context(|| "failed to parse the `edition` key")?;
         package.edition = Some(manifest::InheritableField::Value(edition.to_string()));
-        if let Some(rust_version) = &rust_version {
-            let req = rust_version.to_caret_req();
-            if let Some(first_version) = edition.first_version() {
+        if let Some(pkg_msrv) = &rust_version {
+            let pkg_msrv_req = pkg_msrv.to_caret_req();
+            if let Some(edition_msrv) = edition.first_version() {
                 let unsupported =
-                    semver::Version::new(first_version.major, first_version.minor - 1, 9999);
-                if req.matches(&unsupported) {
+                    semver::Version::new(edition_msrv.major, edition_msrv.minor - 1, 9999);
+                if pkg_msrv_req.matches(&unsupported) {
                     bail!(
                         "rust-version {} is older than first version ({}) required by \
                             the specified edition ({})",
-                        rust_version,
-                        first_version,
+                        pkg_msrv,
+                        edition_msrv,
                         edition,
                     )
                 }
             }
         }
         edition
     } else {
-        let msrv_edition = if let Some(rust_version) = &rust_version {
+        let msrv_edition = if let Some(pkg_msrv) = &rust_version {
             Edition::ALL
                 .iter()
                 .filter(|e| {
                     e.first_version()
-                        .map(|e| {
-                            let e = PartialVersion::from(e);
-                            e <= **rust_version
+                        .map(|edition_msrv| {
+                            let edition_msrv = PartialVersion::from(edition_msrv);
+                            edition_msrv <= **pkg_msrv
                         })
                         .unwrap_or_default()
                 })