Add imported module variables suggestions for unknown variables.

When a variable is not in the current scope, an `Error::UnknownVariable`
is triggered. However the only suggestions were for variables in the
scope with a similar name computed by the "did you mean" algorithm. With
this commit, we also suggest public variables / identifiers (such as
constants, functions or type variant constructor) in imported modules
with the same name.

For example with the following code:
```gleam
import gleam/io

pub fn main() -> Nil {
  println("Hello, World!")
}
```

The suggestions are:
```
  ┌─ /path/to/project/src/project.gleam:4:3
  │
4 │   println("Hello, World!")
  │   ^^^^^^^

The name `println` is not in scope here.
Consider using one of these variables:

        io.println
```

However because we are only checking the name of the variable, we could
have wrong suggestions, as in this case:
```gleam
import gleam/float
import gleam/int

pub fn main() -> Nil {
  to_string(3)
}
```

Here, it is clear that we want suggestions on a function named
`to_string` and accepting one parameter of type `Int`, but this is not
the case:
```
  ┌─ /path/to/project/src/project.gleam:5:3
  │
5 │   to_string(3)
  │   ^^^^^^^^^

The name `to_string` is not in scope here.
Consider using one of these implementations:

        float.to_string
        int.to_string
```

Author: realraphrous

compiler-core/src/error.rs

@@ -2401,9 +2401,9 @@ but no type in scope with that name."
                         discarded_location,
                         name,
                         type_with_name_in_scope,
+                        imported_modules_with_same_public_variable_name,
                     } => {
                         let title = String::from("Unknown variable");
-
                         if let Some(ignored_location) = discarded_location {
                             let location = Location {
                                 label: Label {
@@ -2433,17 +2433,32 @@ but no type in scope with that name."
                             let text = if *type_with_name_in_scope {
                                 wrap_format!("`{name}` is a type, it cannot be used as a value.")
                             } else {
-                                let is_first_char_uppercase =
-                                    name.chars().next().is_some_and(char::is_uppercase);
-
-                                if is_first_char_uppercase {
+                                let mut text = if name.starts_with(char::is_uppercase) {
                                     wrap_format!(
-                                        "The custom type variant constructor \
-`{name}` is not in scope here."
+                                        "The custom type variant constructor `{name}` is not in scope here."
                                     )
-                                } else {
+                                }
+                                else {
                                     wrap_format!("The name `{name}` is not in scope here.")
+                                };
+
+                                // If there are some suggestions about variables in imported modules
+                                // put a "consider" text after the main message
+                                if !imported_modules_with_same_public_variable_name.is_empty() {
+                                    let consider_text = imported_modules_with_same_public_variable_name
+                                        .iter()
+                                        .fold(
+                                            String::from("Consider using one of these variables:\n\n"),
+                                            |mut acc, module_name| {
+                                                acc.push_str(&wrap_format!("    {module_name}.{name}\n"));
+                                                acc
+                                            }
+                                        );
+                                    text.push('\n');
+                                    text.push_str(&consider_text);
                                 }
+
+                                text
                             };
 
                             Diagnostic {

compiler-core/src/type_/environment.rs

@@ -476,14 +476,22 @@ impl Environment<'_> {
         name: &EcoString,
     ) -> Result<&ValueConstructor, UnknownValueConstructorError> {
         match module {
-            None => self.scope.get(name).ok_or_else(|| {
-                let type_with_name_in_scope = self.module_types.keys().any(|type_| type_ == name);
-                UnknownValueConstructorError::Variable {
+            None => self
+                .scope
+                .get(name)
+                .ok_or_else(|| UnknownValueConstructorError::Variable {
                     name: name.clone(),
                     variables: self.local_value_names(),
-                    type_with_name_in_scope,
-                }
-            }),
+                    type_with_name_in_scope: self.module_types.keys().any(|typ| typ == name),
+                    imported_modules_with_same_public_variable_name: self
+                        .imported_modules
+                        .iter()
+                        .filter_map(|(module_name, (_, module))| {
+                            module.get_public_value(name).map(|_| module_name)
+                        })
+                        .cloned()
+                        .collect_vec(),
+                }),
 
             Some(module_name) => {
                 let (_, module) = self.imported_modules.get(module_name).ok_or_else(|| {

compiler-core/src/type_/error.rs

@@ -171,6 +171,9 @@ pub enum Error {
         /// this will contain its location.
         discarded_location: Option<SrcSpan>,
         type_with_name_in_scope: bool,
+        /// Filled with the name of imported modules when the module has public value
+        /// with the same name as this variable
+        imported_modules_with_same_public_variable_name: Vec<EcoString>,
     },
 
     UnknownType {
@@ -1293,6 +1296,7 @@ pub enum UnknownValueConstructorError {
         name: EcoString,
         variables: Vec<EcoString>,
         type_with_name_in_scope: bool,
+        imported_modules_with_same_public_variable_name: Vec<EcoString>,
     },
 
     Module {
@@ -1318,12 +1322,14 @@ pub fn convert_get_value_constructor_error(
             name,
             variables,
             type_with_name_in_scope,
+            imported_modules_with_same_public_variable_name,
         } => Error::UnknownVariable {
             location,
             name,
             variables,
             discarded_location: None,
             type_with_name_in_scope,
+            imported_modules_with_same_public_variable_name,
         },
 
         UnknownValueConstructorError::Module { name, suggestions } => Error::UnknownModule {

compiler-core/src/type_/expression.rs

@@ -3527,6 +3527,15 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     .module_types
                     .keys()
                     .any(|typ| typ == name),
+                imported_modules_with_same_public_variable_name: self
+                    .environment
+                    .imported_modules
+                    .iter()
+                    .filter_map(|(module_name, (_, module))| {
+                        module.get_public_value(name).map(|_| module_name)
+                    })
+                    .cloned()
+                    .collect_vec(),
             },
         }
     }

compiler-core/src/type_/pattern.rs

@@ -1253,6 +1253,15 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                                     .module_types
                                     .keys()
                                     .any(|type_| type_ == &name),
+                                imported_modules_with_same_public_variable_name: self
+                                    .environment
+                                    .imported_modules
+                                    .iter()
+                                    .filter_map(|(module_name, (_, module))| {
+                                        module.get_public_value(&name).map(|_| module_name)
+                                    })
+                                    .cloned()
+                                    .collect_vec(),
                             });
                         }
                     },