@@ -1,7 +1,6 @@
 use std::{fmt::Display, str::FromStr};
 
 use miette::{Context, IntoDiagnostic, Result};
-use rustc_version::Channel;
 
 use crate::error::BuildError;
 
@@ -27,21 +26,18 @@ impl Arch {
 #[derive(Debug)]
 pub struct TargetArch {
     rustc_target: String,
-    channel: Option<Channel>,
 }
 
 impl TargetArch {
     pub fn arm64() -> Self {
         Self {
             rustc_target: TARGET_ARM.into(),
-            channel: None,
         }
     }
 
     pub fn x86_64() -> Self {
         Self {
             rustc_target: TARGET_X86_64.into(),
-            channel: None,
         }
     }
 
@@ -53,7 +49,6 @@ impl TargetArch {
         if !target.compatible_host_linker() {
             target = TargetArch::x86_64();
         }
-        target.channel = Some(rustc_meta.channel);
         Ok(target)
     }
 
@@ -85,16 +80,6 @@ impl TargetArch {
         false
     }
 
-    pub fn channel(&self) -> Result<Channel> {
-        match self.channel {
-            Some(c) => Ok(c),
-            None => rustc_version::version_meta()
-                .map(|m| m.channel)
-                .into_diagnostic()
-                .wrap_err("error reading Rust version information"),
-        }
-    }
-
     pub fn rustc_target_without_glibc_version(&self) -> &str {
         let Some((rustc_target_without_glibc_version, _)) = self.rustc_target.split_once('.')
         else {
@@ -117,7 +102,6 @@ impl FromStr for TargetArch {
     fn from_str(host: &str) -> Result<Self, Self::Err> {
         Ok(Self {
             rustc_target: host.into(),
-            channel: None,
         })
     }
 }
 
@@ -3,7 +3,6 @@ use cargo_lambda_interactive::{
     progress::Progress,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
-use rustc_version::Channel;
 use std::{env, str};
 
 use crate::target_arch::TargetArch;
@@ -13,16 +12,8 @@ use crate::target_arch::TargetArch;
 pub async fn check_target_component_with_rustc_meta(target_arch: &TargetArch) -> Result<()> {
     let component = target_arch.rustc_target_without_glibc_version();
 
-    // convert `Channel` enum to a lower-cased string representation
-    let toolchain = match target_arch.channel()? {
-        Channel::Stable => "stable",
-        Channel::Nightly => "nightly",
-        Channel::Dev => "dev",
-        Channel::Beta => "beta",
-    };
-
     let cmd = rustup_cmd();
-    let args = [&format!("+{toolchain}"), "target", "list", "--installed"];
+    let args = ["target", "list", "--installed"];
 
     tracing::trace!(
         cmd = ?cmd,
@@ -49,7 +40,7 @@ pub async fn check_target_component_with_rustc_meta(target_arch: &TargetArch) ->
         // install target component using `rustup`
         let pb = Progress::start(format!("Installing target component `{component}`..."));
 
-        let result = install_target_component(component, toolchain).await;
+        let result = install_target_component(component).await;
         let finish = if result.is_ok() {
             "Target component installed"
         } else {
@@ -63,9 +54,9 @@ pub async fn check_target_component_with_rustc_meta(target_arch: &TargetArch) ->
 }
 
 /// Install target component in the host toolchain, using `rustup target add`
-async fn install_target_component(component: &str, toolchain: &str) -> Result<()> {
+async fn install_target_component(component: &str) -> Result<()> {
     let cmd = rustup_cmd();
-    let args = [&format!("+{toolchain}"), "target", "add", component];
+    let args = ["target", "add", component];
     tracing::trace!(
         cmd = ?cmd,
         args = ?args,
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`use std::{fmt::Display, str::FromStr};`
`2`	`2`
`3`	`3`	`use miette::{Context, IntoDiagnostic, Result};`
`4`		`-use rustc_version::Channel;`
`5`	`4`
`6`	`5`	`use crate::error::BuildError;`
`7`	`6`
`@@ -27,21 +26,18 @@ impl Arch {`
`27`	`26`	`#[derive(Debug)]`
`28`	`27`	`pub struct TargetArch {`
`29`	`28`	`rustc_target: String,`
`30`		`- channel: Option<Channel>,`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`impl TargetArch {`
`34`	`32`	`pub fn arm64() -> Self {`
`35`	`33`	`Self {`
`36`	`34`	`rustc_target: TARGET_ARM.into(),`
`37`		`- channel: None,`
`38`	`35`	`}`
`39`	`36`	`}`
`40`	`37`
`41`	`38`	`pub fn x86_64() -> Self {`
`42`	`39`	`Self {`
`43`	`40`	`rustc_target: TARGET_X86_64.into(),`
`44`		`- channel: None,`
`45`	`41`	`}`
`46`	`42`	`}`
`47`	`43`
`@@ -53,7 +49,6 @@ impl TargetArch {`
`53`	`49`	`if !target.compatible_host_linker() {`
`54`	`50`	`target = TargetArch::x86_64();`
`55`	`51`	`}`
`56`		`- target.channel = Some(rustc_meta.channel);`
`57`	`52`	`Ok(target)`
`58`	`53`	`}`
`59`	`54`
`@@ -85,16 +80,6 @@ impl TargetArch {`
`85`	`80`	`false`
`86`	`81`	`}`
`87`	`82`
`88`		`- pub fn channel(&self) -> Result<Channel> {`
`89`		`- match self.channel {`
`90`		`- Some(c) => Ok(c),`
`91`		`- None => rustc_version::version_meta()`
`92`		`- .map(\|m\| m.channel)`
`93`		`- .into_diagnostic()`
`94`		`- .wrap_err("error reading Rust version information"),`
`95`		`- }`
`96`		`- }`
`97`		`-`
`98`	`83`	`pub fn rustc_target_without_glibc_version(&self) -> &str {`
`99`	`84`	`let Some((rustc_target_without_glibc_version, _)) = self.rustc_target.split_once('.')`
`100`	`85`	`else {`
`@@ -117,7 +102,6 @@ impl FromStr for TargetArch {`
`117`	`102`	`fn from_str(host: &str) -> Result<Self, Self::Err> {`
`118`	`103`	`Ok(Self {`
`119`	`104`	`rustc_target: host.into(),`
`120`		`- channel: None,`
`121`	`105`	`})`
`122`	`106`	`}`
`123`	`107`	`}`