Fixes for Rust 1.89 (#313)

* Fixes for Rust 1.89

* move comment

Author: noise64

golem-cli/src/app/build/gen_rpc.rs

@@ -221,7 +221,7 @@ async fn create_generated_base_wit(
                             {
                                 ctx.component_base_output_wit_deps(dep_component_name)?
                                     .add_packages_with_transitive_deps_to_wit_dir(
-                                        &[dep_exports_package_name.clone()],
+                                        std::slice::from_ref(dep_exports_package_name),
                                         &component_generated_base_wit,
                                     )?;
                             }

golem-cli/src/fs.rs

@@ -274,7 +274,7 @@ impl<P: AsRef<Path>> PathExtra<P> {
         self.0.as_ref().into()
     }
 
-    pub fn display(&self) -> std::path::Display {
+    pub fn display(&self) -> std::path::Display<'_> {
         self.as_path().display()
     }
 }

golem-cli/src/model/worker.rs

@@ -45,33 +45,30 @@ pub fn fuzzy_match_function_name(
     let fuzzy_search = FuzzySearch::new(component_function_names.iter().map(|s| s.as_str()));
     match fuzzy_search.find(&normalized_function_name) {
         Ok(matched) => {
-            // if we have a match, but it is non-exact _or_ we have a parsed function name, we customize the parsed function name and render it
-            // because it may have resource parameters
-            if parsed_function_name.is_some()
-                && (!matched.exact_match
-                    || parsed_function_name
-                        .iter()
-                        .any(|f| f.function.is_indexed_resource()))
-            {
-                let mut parsed_function_name = parsed_function_name.unwrap();
-                let parsed_matched_function_name = ParsedFunctionName::parse(&matched.option)
-                    .expect("The rendered component export names should always be parseable");
-
-                adjust_parsed_function_name(
-                    &mut parsed_function_name,
-                    parsed_matched_function_name,
-                    normalized_function_name,
-                )?;
-
-                let rendered_altered_function_name = parsed_function_name.to_string();
-                Ok(Match {
-                    option: rendered_altered_function_name,
-                    pattern: matched.pattern,
-                    exact_match: false,
-                })
-            } else {
-                // otherwise we just return the matched raw function name
-                Ok(normalized(matched))
+            match parsed_function_name {
+                // if we have a match, but it is non-exact _or_ we have a parsed function name, we customize the parsed function name and render it
+                // because it may have resource parameters
+                Some(mut parsed_function_name)
+                    if !matched.exact_match
+                        || parsed_function_name.function.is_indexed_resource() =>
+                {
+                    let parsed_matched_function_name = ParsedFunctionName::parse(&matched.option)
+                        .expect("The rendered component export names should always be parseable");
+
+                    adjust_parsed_function_name(
+                        &mut parsed_function_name,
+                        parsed_matched_function_name,
+                        normalized_function_name,
+                    )?;
+
+                    let rendered_altered_function_name = parsed_function_name.to_string();
+                    Ok(Match {
+                        option: rendered_altered_function_name,
+                        pattern: matched.pattern,
+                        exact_match: false,
+                    })
+                }
+                _ => Ok(normalized(matched)),
             }
         }
         Err(Error::Ambiguous {