Correct error message text for runtime

Author: lpil

compiler-cli/src/build_lock.rs

@@ -18,6 +18,10 @@ impl BuildLock {
     pub fn new_target(paths: &ProjectPaths, mode: Mode, target: Target) -> Result<Self> {
         let directory = paths.build_directory();
         crate::fs::mkdir(&directory)?;
+        let target = match target {
+            Target::Erlang => "erlang",
+            Target::JavaScript => "javascript",
+        };
         Ok(Self {
             directory,
             filename: format!("gleam-{mode}-{target}.lock"),

compiler-core/src/build.rs

@@ -64,16 +64,14 @@ pub enum Target {
     JavaScript,
 }
 
-impl Display for Target {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Target {
+    pub fn as_presentable_str(&self) -> &str {
         match self {
-            Target::Erlang => write!(f, "Erlang"),
-            Target::JavaScript => write!(f, "JavaScript"),
+            Target::Erlang => "Erlang",
+            Target::JavaScript => "JavaScript",
         }
     }
-}
 
-impl Target {
     pub fn variant_strings() -> Vec<EcoString> {
         Self::VARIANTS.iter().map(|s| (*s).into()).collect()
     }
@@ -127,7 +125,7 @@ impl Codegen {
 }
 
 #[derive(
-    Debug, Serialize, Deserialize, Display, EnumString, EnumVariantNames, Clone, Copy, PartialEq, Eq,
+    Debug, Serialize, Deserialize, EnumString, EnumVariantNames, Clone, Copy, PartialEq, Eq,
 )]
 pub enum Runtime {
     #[strum(serialize = "nodejs", serialize = "node")]
@@ -141,6 +139,16 @@ pub enum Runtime {
     Bun,
 }
 
+impl Runtime {
+    pub fn as_presentable_str(&self) -> &str {
+        match self {
+            Runtime::NodeJs => "NodeJS",
+            Runtime::Deno => "Deno",
+            Runtime::Bun => "Bun",
+        }
+    }
+}
+
 impl Default for Runtime {
     fn default() -> Self {
         Self::NodeJs

compiler-core/src/error.rs

@@ -220,7 +220,7 @@ file_names.iter().map(|x| x.as_str()).join(", "))]
     #[error("warnings are not permitted")]
     ForbiddenWarnings { count: usize },
 
-    #[error("Invalid runtime for {target} target: {invalid_runtime}")]
+    #[error("Invalid runtime for target {target:?}: {invalid_runtime:?}")]
     InvalidRuntime {
         target: Target,
         invalid_runtime: Runtime,
@@ -963,7 +963,8 @@ forward slash and must not end with a slash."
                 title: "Target not supported".into(),
                 text: wrap_format!(
                     "`{module}` has a main function, but it does not support the {target} \
-target, so it cannot be run."
+target, so it cannot be run.",
+                    target = target.as_presentable_str(),
                 ),
                 level: Level::Error,
                 location: None,
@@ -3110,7 +3111,8 @@ a size are only allowed at the end of a bin pattern.",
                                 "Unsupported endianness",
                                 vec![wrap_format!(
                                     "The {target} target does not support the `native` \
-endianness option."
+endianness option.",
+                                    target = target.as_presentable_str(),
                                 )],
                             ),
                             bit_array::ErrorType::OptionNotSupportedForTarget {
@@ -3120,7 +3122,8 @@ endianness option."
                                 "UTF-codepoint pattern matching is not supported",
                                 vec![wrap_format!(
                                     "The {target} target does not support \
-UTF-codepoint pattern matching."
+UTF-codepoint pattern matching.",
+                                    target = target.as_presentable_str(),
                                 )],
                             ),
                         };
@@ -4539,7 +4542,11 @@ satisfying {required_version} but you are using v{gleam_version}.",
                 target,
                 invalid_runtime,
             } => {
-                let text = format!("Invalid runtime for {target} target: {invalid_runtime}");
+                let text = format!(
+                    "Invalid runtime for {target} target: {invalid_runtime}",
+                    target = target.as_presentable_str(),
+                    invalid_runtime = invalid_runtime.as_presentable_str(),
+                );
 
                 let hint = match target {
                     Target::JavaScript => {
@@ -4552,7 +4559,10 @@ satisfying {required_version} but you are using v{gleam_version}.",
                 };
 
                 vec![Diagnostic {
-                    title: format!("Invalid runtime for {target}"),
+                    title: format!(
+                        "Invalid runtime for {target}",
+                        target = target.as_presentable_str(),
+                    ),
                     text,
                     hint,
                     location: None,

compiler-core/src/paths.rs

@@ -96,7 +96,11 @@ impl ProjectPaths {
     }
 
     pub fn build_directory_for_target(&self, mode: Mode, target: Target) -> Utf8PathBuf {
-        self.build_directory_for_mode(mode).join(target.to_string())
+        let target = match target {
+            Target::Erlang => "erlang",
+            Target::JavaScript => "javascript",
+        };
+        self.build_directory_for_mode(mode).join(target)
     }
 
     /// Note this uses the "application name", not the name of this package.

test-output/src/tests/echo.rs

@@ -114,11 +114,22 @@ macro_rules! assert_echo {
 }
 
 fn snapshot_name(target: Option<Target>, runtime: Option<Runtime>, suffix: &str) -> String {
+    let show_target = |target: Target| match target {
+        Target::Erlang => "erlang",
+        Target::JavaScript => "javascript",
+    };
+    let show_runtime = |runtime: Runtime| match runtime {
+        Runtime::NodeJs => "nodejs",
+        Runtime::Deno => "deno",
+        Runtime::Bun => "bun",
+    };
     let prefix = match (target, runtime) {
         (None, None) => "".into(),
-        (None, Some(runtime)) => format!("{runtime}-"),
-        (Some(target), None) => format!("{target}-"),
-        (Some(target), Some(runtime)) => format!("{target}-{runtime}-"),
+        (None, Some(runtime)) => format!("{}-", show_runtime(runtime)),
+        (Some(target), None) => format!("{}-", show_target(target)),
+        (Some(target), Some(runtime)) => {
+            format!("{}-{}-", show_target(target), show_runtime(runtime))
+        }
     };
     format!("{prefix}{suffix}")
 }