stop suggesting to use a value discarded in a different function

Author: giacomocavalieri

CHANGELOG.md

@@ -74,7 +74,7 @@
 
 - The compiler will now raise warning for inefficient use of `list.length()`
   when trying to check is list empty via `0 < list.length(list)` or
-`list.length(list) > 0` as well as in other cases. For example, the following
+  `list.length(list) > 0` as well as in other cases. For example, the following
   code:
 
   ```gleam
@@ -375,3 +375,7 @@
 - Fixed a bug where adding `echo` to the subject of a `case` expression would
   prevent variant inference from working correctly.
   ([Surya Rose](https://github.com/GearsDatapacks))
+
+- Fixed a bug where the compiler would suggest to use a discarded value defined
+  in a different function.
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))

compiler-core/src/analyse.rs

@@ -560,31 +560,35 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             has_javascript_external: external_javascript.is_some(),
         };
 
-        let mut typed_arguments = Vec::with_capacity(arguments.len());
-        for (argument, type_) in arguments.into_iter().zip(&prereg_arguments_types) {
-            let argument = argument.set_type(type_.clone());
-            match &argument.names {
-                ast::ArgNames::Named { .. } | ast::ArgNames::NamedLabelled { .. } => (),
-                ast::ArgNames::Discard { name, location }
-                | ast::ArgNames::LabelledDiscard {
-                    name,
-                    name_location: location,
-                    ..
-                } => {
-                    let _ = environment.discarded_names.insert(name.clone(), *location);
-                }
-            }
-
-            typed_arguments.push(argument);
-        }
-
         // We have already registered the function in the `register_value_from_function`
         // method, but here we must set this as the current function again, so that anything
         // we reference in the body of it can be tracked properly in the call graph.
         environment.references.set_current_node(name.clone());
 
+        let mut typed_arguments = Vec::with_capacity(arguments.len());
+
         // Infer the type using the preregistered args + return types as a starting point
         let result = environment.in_new_scope(&mut self.problems, |environment, problems| {
+            for (argument, type_) in arguments.into_iter().zip(&prereg_arguments_types) {
+                let argument = argument.set_type(type_.clone());
+
+                // We track which arguments are discarded so we can provide nice
+                // error messages when someone
+                match &argument.names {
+                    ast::ArgNames::Named { .. } | ast::ArgNames::NamedLabelled { .. } => (),
+                    ast::ArgNames::Discard { name, location }
+                    | ast::ArgNames::LabelledDiscard {
+                        name,
+                        name_location: location,
+                        ..
+                    } => {
+                        let _ = environment.discarded_names.insert(name.clone(), *location);
+                    }
+                }
+
+                typed_arguments.push(argument);
+            }
+
             let mut expr_typer = ExprTyper::new(environment, definition, problems);
             expr_typer.hydrator = self
                 .hydrators

compiler-core/src/type_/tests/warnings.rs

@@ -4304,3 +4304,13 @@ fn unused_discard_pattern() {
 "
     );
 }
+
+#[test]
+fn discarded_argument_suggestion_is_not_given_for_different_functions() {
+    assert_no_warnings!(
+        "
+pub fn main(_x) { 1 }
+pub fn wibble() { x }
+"
+    );
+}