Add suggestions for pipeline similar to function but with arity of 1.

At this stage, pipeline are not considered as `Call` so previous work
on `UntypedExpr::Call` does not apply directly to pipeline. With this
change, we handle the pipeline case when the function / constructor is
not a `Call`.

```gleam
1 |> to_string
```

When there is a call in the pipeline, it is more delicate to address
because something like that:
```gleam
1 |> add(2)
```
Can be desugared into two possibilities and so suggestions are not the
same. The function `report_name_error` does not have enough context to
make good suggestions:
```gleam
add(1, 2)
add(2)(1)
```

In this case, we just suggest every functions.

Author: realraphrous

compiler-core/src/type_.rs

@@ -1662,12 +1662,14 @@ pub enum FieldAccessUsage {
     Other,
 }
 
-/// This is used to know when a variable is used as a value or as a call:
+/// This is used to know when a variable is used as a value or as a call: a zzzz
 /// function call, a pipeline or a custom type variant constructor
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum VarUsage {
-    /// Used as `variable()`
+    /// Used as `call()` or `left |> right`
     Call { arity: usize },
+    /// Used as `left |> right(..)`
+    PipelineCall,
     /// Used as `variable`
     Other,
 }

compiler-core/src/type_/expression.rs

@@ -727,7 +727,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
     }
 
     // Helper to create a new error expr.
-    fn error_expr(&mut self, location: SrcSpan) -> TypedExpr {
+    pub(crate) fn error_expr(&mut self, location: SrcSpan) -> TypedExpr {
         TypedExpr::Invalid {
             location,
             type_: self.new_unbound_var(),
@@ -1138,7 +1138,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         }
     }
 
-    fn infer_var(
+    pub(crate) fn infer_var(
         &mut self,
         name: EcoString,
         location: SrcSpan,
@@ -3555,6 +3555,22 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                         })
                         .cloned()
                         .collect_vec(),
+                    // This is a `Call` into a `Pipeline`. This is hard to make
+                    // good suggestions because of the way it can be desugared.
+                    // In this case, return every functions with the same name
+                    // even if they have wrong arity.
+                    VarUsage::PipelineCall => self
+                        .environment
+                        .imported_modules
+                        .iter()
+                        .filter_map(|(module_name, (_, module))| {
+                            module
+                                .get_public_value(name)
+                                .filter(|value_constructor| value_constructor.type_.is_fun())
+                                .map(|_| module_name)
+                        })
+                        .cloned()
+                        .collect_vec(),
                     // This is a reference to a variable, we need to suggest
                     // public variables of any type
                     VarUsage::Other => self
@@ -4632,7 +4648,7 @@ fn is_trusted_pure_module(environment: &Environment<'_>) -> bool {
 }
 
 #[derive(Debug, Clone, Copy)]
-enum ReferenceRegistration {
+pub(crate) enum ReferenceRegistration {
     RegisterReferences,
     DoNotRegisterReferences,
 }

compiler-core/src/type_/pipe.rs

@@ -1,6 +1,6 @@
 use self::expression::CallKind;
 
-use super::*;
+use super::{expression::ReferenceRegistration, *};
 use crate::ast::{
     FunctionLiteralKind, ImplicitCallArgOrigin, PIPE_VARIABLE, PipelineAssignmentKind, Statement,
     TypedPipelineAssignment, UntypedExpr,
@@ -139,17 +139,24 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
                     location,
                     ..
                 } => {
-                    let fun = match self.expr_typer.infer_or_error(*fun) {
+                    let fun_result = match *fun {
+                        UntypedExpr::Var { location, name } => self.expr_typer.infer_var(
+                            name,
+                            location,
+                            VarUsage::PipelineCall,
+                            ReferenceRegistration::RegisterReferences,
+                        ),
+                        fun => self.expr_typer.infer_or_error(fun),
+                    };
+
+                    let fun = match fun_result {
                         Ok(fun) => fun,
                         Err(e) => {
                             // In case we cannot infer the function we'll
                             // replace it with an invalid expression with an
                             // unbound type to keep going!
                             self.expr_typer.problems.error(e);
-                            TypedExpr::Invalid {
-                                location,
-                                type_: self.expr_typer.new_unbound_var(),
-                            }
+                            self.expr_typer.error_expr(location)
                         }
                     };
 
@@ -350,16 +357,26 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
     /// b is the `function` argument.
     fn infer_apply_pipe(&mut self, function: UntypedExpr) -> TypedExpr {
         let function_location = function.location();
-        let function = Box::new(match self.expr_typer.infer_or_error(function) {
+        // Need one more step for better error suggestion. If the function is
+        // a variable / identifier, then we can suggest variables / identifier
+        // from imported modules with the same name and same arity.
+        let function_result = match function {
+            UntypedExpr::Var { location, name } => self.expr_typer.infer_var(
+                name,
+                location,
+                VarUsage::Call { arity: 1 },
+                ReferenceRegistration::RegisterReferences,
+            ),
+            _ => self.expr_typer.infer_or_error(function),
+        };
+
+        let function = Box::new(match function_result {
             Ok(function) => function,
             Err(error) => {
                 // If we cannot infer the function we put an invalid expression
                 // in its place so we can still keep going with the other steps.
                 self.expr_typer.problems.error(error);
-                TypedExpr::Invalid {
-                    location: function_location,
-                    type_: self.expr_typer.new_unbound_var(),
-                }
+                self.expr_typer.error_expr(function_location)
             }
         });