Make compiler hint to import unqualified types/values

compiler-core/src/error.rs

@@ -2268,6 +2268,7 @@ Note: If the same type variable is used for multiple fields, all those fields ne
                     location,
                     name,
                     hint,
+                    suggestions
                 } => {
                     let label_text = match hint {
                         UnknownTypeHint::AlternativeTypes(types) => did_you_mean(name, types),
@@ -2292,7 +2293,10 @@ but no type in scope with that name."
                     Diagnostic {
                         title: "Unknown type".into(),
                         text,
-                        hint: None,
+                        hint: match label_text {
+                            None => suggestions.first().map(|suggestion| suggestion.suggestion(name, true)),
+                            Some(_) => None
+                        },
                         level: Level::Error,
                         location: Some(Location {
                             label: Label {
@@ -2311,6 +2315,7 @@ but no type in scope with that name."
                     variables,
                     name,
                     type_with_name_in_scope,
+                    suggestions
                 } => {
                     let text = if *type_with_name_in_scope {
                         wrap_format!("`{name}` is a type, it cannot be used as a value.")
@@ -2326,7 +2331,7 @@ but no type in scope with that name."
                     Diagnostic {
                         title: "Unknown variable".into(),
                         text,
-                        hint: None,
+                        hint: suggestions.first().map(|suggestion| suggestion.suggestion(name, false)),
                         level: Level::Error,
                         location: Some(Location {
                             label: Label {

compiler-core/src/type_/environment.rs

@@ -392,6 +392,8 @@ impl Environment<'_> {
                 .ok_or_else(|| UnknownTypeConstructorError::Type {
                     name: name.clone(),
                     hint: self.unknown_type_hint(name),
+                    suggestions: self
+                        .suggest_modules_for_type_or_value(Imported::Type(name.clone())),
                 }),
 
             Some((module_name, _)) => {
@@ -440,6 +442,8 @@ impl Environment<'_> {
                 UnknownTypeConstructorError::Type {
                     name: name.clone(),
                     hint: self.unknown_type_hint(name),
+                    suggestions: self
+                        .suggest_modules_for_type_or_value(Imported::Type(name.clone())),
                 }
             }),
 
@@ -476,6 +480,8 @@ impl Environment<'_> {
                     name: name.clone(),
                     variables: self.local_value_names(),
                     type_with_name_in_scope,
+                    suggestions: self
+                        .suggest_modules_for_type_or_value(Imported::Value(name.clone())),
                 }
             }),
 
@@ -741,6 +747,50 @@ impl Environment<'_> {
             .collect()
     }
 
+    /// Suggest modules to import or use, for an unqualified type
+    pub fn suggest_modules_for_type_or_value(
+        &self,
+        imported: Imported,
+    ) -> Vec<TypeOrVariableSuggestion> {
+        let mut suggestions = self
+            .importable_modules
+            .iter()
+            .filter_map(|(importable, module_info)| {
+                match &imported {
+                    // Don't suggest importing modules if they are already imported
+                    _ if self
+                        .imported_modules
+                        .contains_key(importable.split('/').last().unwrap_or(importable)) =>
+                    {
+                        None
+                    }
+                    Imported::Type(name) if module_info.get_public_type(name).is_some() => {
+                        Some(TypeOrVariableSuggestion::Importable(importable.clone()))
+                    }
+                    Imported::Value(name) if module_info.get_public_value(name).is_some() => {
+                        Some(TypeOrVariableSuggestion::Importable(importable.clone()))
+                    }
+                    _ => None,
+                }
+            })
+            .collect_vec();
+
+        suggestions.extend(self.imported_modules.iter().filter_map(
+            |(module, (_, module_info))| match &imported {
+                Imported::Type(name) if module_info.get_public_type(name).is_some() => {
+                    Some(TypeOrVariableSuggestion::Imported(module.clone()))
+                }
+                Imported::Value(name) if module_info.get_public_value(name).is_some() => {
+                    Some(TypeOrVariableSuggestion::Imported(module.clone()))
+                }
+                _ => None,
+            },
+        ));
+
+        // Filter and sort options based on if its already imported and on alphabetical order.
+        suggestions.into_iter().sorted().collect()
+    }
+
     /// Suggest modules to import or use, for an unknown module
     pub fn suggest_modules(&self, module: &str, imported: Imported) -> Vec<ModuleSuggestion> {
         let mut suggestions = self

compiler-core/src/type_/error.rs

@@ -108,6 +108,38 @@ pub enum UnknownField {
     NoFields,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TypeOrVariableSuggestion {
+    Imported(EcoString),
+    Importable(EcoString),
+}
+
+impl TypeOrVariableSuggestion {
+    pub fn suggestion(&self, name: &str, is_type: bool) -> String {
+        let module = self.name();
+
+        if is_type {
+            format!("Did you mean to import `{module}.{{type {name}}}`?")
+        } else {
+            format!("Did you mean to import `{module}.{{{name}}}`")
+        }
+    }
+
+    pub fn name(&self) -> &EcoString {
+        match self {
+            TypeOrVariableSuggestion::Imported(name)
+            | TypeOrVariableSuggestion::Importable(name) => name,
+        }
+    }
+
+    pub fn last_name_component(&self) -> &str {
+        match self {
+            TypeOrVariableSuggestion::Imported(name)
+            | TypeOrVariableSuggestion::Importable(name) => name.split('/').last().unwrap_or(name),
+        }
+    }
+}
+
 /// A suggestion for an unknown module
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ModuleSuggestion {
@@ -173,12 +205,14 @@ pub enum Error {
         name: EcoString,
         variables: Vec<EcoString>,
         type_with_name_in_scope: bool,
+        suggestions: Vec<TypeOrVariableSuggestion>,
     },
 
     UnknownType {
         location: SrcSpan,
         name: EcoString,
         hint: UnknownTypeHint,
+        suggestions: Vec<TypeOrVariableSuggestion>,
     },
 
     UnknownModule {
@@ -1153,6 +1187,7 @@ pub enum UnknownValueConstructorError {
         name: EcoString,
         variables: Vec<EcoString>,
         type_with_name_in_scope: bool,
+        suggestions: Vec<TypeOrVariableSuggestion>,
     },
 
     Module {
@@ -1178,11 +1213,13 @@ pub fn convert_get_value_constructor_error(
             name,
             variables,
             type_with_name_in_scope,
+            suggestions,
         } => Error::UnknownVariable {
             location,
             name,
             variables,
             type_with_name_in_scope,
+            suggestions,
         },
 
         UnknownValueConstructorError::Module { name, suggestions } => Error::UnknownModule {
@@ -1236,6 +1273,7 @@ pub enum UnknownTypeConstructorError {
     Type {
         name: EcoString,
         hint: UnknownTypeHint,
+        suggestions: Vec<TypeOrVariableSuggestion>,
     },
 
     Module {
@@ -1257,10 +1295,15 @@ pub fn convert_get_type_constructor_error(
     module_location: Option<SrcSpan>,
 ) -> Error {
     match e {
-        UnknownTypeConstructorError::Type { name, hint } => Error::UnknownType {
+        UnknownTypeConstructorError::Type {
+            name,
+            hint,
+            suggestions,
+        } => Error::UnknownType {
             location: *location,
             name,
             hint,
+            suggestions,
         },
 
         UnknownTypeConstructorError::Module { name, suggestions } => Error::UnknownModule {

compiler-core/src/type_/expression.rs

@@ -2943,6 +2943,9 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     .module_types
                     .keys()
                     .any(|typ| typ == name),
+                suggestions: self
+                    .environment
+                    .suggest_modules_for_type_or_value(Imported::Value(name.clone())),
             },
         }
     }

compiler-core/src/type_/hydrator.rs

@@ -250,6 +250,8 @@ impl Hydrator {
                             name: name.clone(),
                             location: *location,
                             hint,
+                            suggestions: environment
+                                .suggest_modules_for_type_or_value(Imported::Type(name.clone())),
                         })
                     }
                 }

compiler-core/src/type_/pattern.rs

@@ -426,6 +426,9 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                             .module_types
                             .keys()
                             .any(|type_| type_ == &name),
+                        suggestions: self
+                            .environment
+                            .suggest_modules_for_type_or_value(Imported::Value(name.clone())),
                     })?;
                 self.environment.increment_usage(&name);
                 let type_ =

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__same_imports_multiple_times.snap

@@ -35,3 +35,4 @@ error: Unknown variable
   │                                  ^^^
 
 The name `zoo` is not in scope here.
+Hint: Did you mean to import `wibble.{zoo}`

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__imports__imported_constructor_instead_of_type.snap

@@ -23,3 +23,4 @@ error: Unknown type
 The type `Wibble` is not defined or imported in this module.
 There is a value in scope with the name `Wibble`, but no type in scope with
 that name.
+Hint: Did you mean to import `module.{type Wibble}`?