Make sure that list of plugins is sorted and unique

forc/src/cli/commands/plugins.rs

@@ -1,8 +1,12 @@
 use crate::cli::PluginsCommand;
 use anyhow::anyhow;
 use clap::Parser;
+use forc_tracing::println_warning;
 use forc_util::ForcResult;
-use std::path::{Path, PathBuf};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
 use tracing::info;
 
 /// Find all forc plugins available via `PATH`.
@@ -18,15 +22,62 @@ pub struct Command {
     describe: bool,
 }
 
+fn get_file_name(path: &Path) -> String {
+    if let Some(Some(path_str)) = path.file_name().map(|path_str| path_str.to_str()) {
+        path_str.to_owned()
+    } else {
+        path.display().to_string()
+    }
+}
+
 pub(crate) fn exec(command: PluginsCommand) -> ForcResult<()> {
     let PluginsCommand {
         print_full_path,
         describe,
     } = command;
 
+    let mut plugins = crate::cli::plugin::find_all()
+        .map(|path| print_plugin(path.clone(), print_full_path, describe).map(|info| (path, info)))
+        .collect::<Result<Vec<(_, _)>, _>>()?
+        .into_iter()
+        .fold(HashMap::new(), |mut acc, (path, content)| {
+            let bin_name = get_file_name(&path);
+            acc.entry(bin_name.clone())
+                .or_insert_with(|| (bin_name, vec![], content.clone()))
+                .1
+                .push(path);
+            acc
+        })
+        .into_values()
+        .map(|(bin_name, paths, content)| {
+            let mut temp_hashmap = HashMap::new();
+            (
+                bin_name,
+                paths
+                    .into_iter()
+                    .filter_map(|path| {
+                        if temp_hashmap.get(&path).is_some() {
+                            return None;
+                        }
+                        temp_hashmap.insert(path.clone(), true);
+                        Some(path)
+                    })
+                    .collect::<Vec<_>>(),
+                content,
+            )
+        })
+        .collect::<Vec<_>>();
+    plugins.sort_by(|a, b| a.0.cmp(&b.0));
+
     info!("Installed Plugins:");
-    for path in crate::cli::plugin::find_all() {
-        info!("{}", print_plugin(path, print_full_path, describe)?);
+    for plugin in plugins {
+        info!("{}", plugin.2);
+        if plugin.1.len() > 1 {
+            println_warning(&format!("Multiple path found for {}", plugin.0));
+            for path in plugin.1 {
+                println_warning(&format!("   {}", path.display()));
+            }
+        }
     }
     Ok(())
 }
@@ -72,11 +123,7 @@ fn format_print_description(
     let display = if print_full_path {
         path.display().to_string()
     } else {
-        path.file_name()
-            .expect("Failed to read file name")
-            .to_str()
-            .expect("Failed to print file name")
-            .to_string()
+        get_file_name(&path)
     };
 
     let description = parse_description_for_plugin(&path);

forc/src/cli/mod.rs

@@ -106,7 +106,7 @@ pub async fn run_cli() -> ForcResult<()> {
         Forc::ContractId(command) => contract_id::exec(command),
         Forc::PredicateRoot(command) => predicate_root::exec(command),
         Forc::Plugin(args) => {
-            let output = plugin::execute_external_subcommand(args)?;
+            let output = plugin::execute_external_subcommand(args, opt.silent)?;
             let code = output
                 .status
                 .code()

forc/src/cli/plugin.rs

@@ -1,6 +1,7 @@
 //! Items related to plugin support for `forc`.
 
 use anyhow::{bail, Result};
+use forc_tracing::println_warning;
 use std::{
     env, fs,
     path::{Path, PathBuf},
@@ -14,14 +15,29 @@ use std::{
 ///
 /// E.g. given `foo bar baz` where `foo` is an unrecognized subcommand to `forc`, tries to execute
 /// `forc-foo bar baz`.
-pub(crate) fn execute_external_subcommand(args: Vec<String>) -> Result<process::Output> {
+pub(crate) fn execute_external_subcommand(
+    args: Vec<String>,
+    silent: bool,
+) -> Result<process::Output> {
     let cmd = args.get(0).expect("`args` must not be empty");
     let args = &args[1..];
     let path = find_external_subcommand(cmd);
     let command = match path {
         Some(command) => command,
         None => bail!("no such subcommand: `{}`", cmd),
     };
+
+    if let Ok(forc_path) = std::env::current_exe() {
+        if !silent && command.parent() != forc_path.parent() {
+            println_warning(&format!(
+                "The {} ({}) plugin is in a different directory than forc ({})\n",
+                cmd,
+                command.display(),
+                forc_path.display(),
+            ));
+        }
+    }
+
     let output = process::Command::new(command)
         .stdin(process::Stdio::inherit())
         .stdout(process::Stdio::inherit())