Improve error messages for constants defined in functions

Author: GearsDatapacks

CHANGELOG.md

@@ -117,6 +117,32 @@
 
   ([Andrey Kozhev](https://github.com/ankddev))
 
+- The compiler now provides an improved error message for when trying to define
+  a constant inside a function. For example, the following code:
+
+  ```gleam
+  pub fn deep_thought() {
+    const the_answer = 42
+    the_answer
+  }
+  ```
+
+  Will produce this error message:
+
+  ```txt
+    error: Syntax error
+    ┌─ /src/file.gleam:2:3
+    │
+  3 │   const the_answer = 43
+    │   ^^^^^ Constants are not allowed inside functions
+
+  All variables are immutable in Gleam, so constants inside functions are not
+  necessary.
+  Hint: Either move this into the global scope or use `let` binding instead.
+  ```
+
+  ([Surya Rose](https://github.com/GearsDatapacks))
+
 ### Build tool
 
 - New projects are generated using OTP28 on GitHub Actions.

compiler-core/src/parse.rs

@@ -803,11 +803,19 @@ where
                 return parse_error(ParseErrorType::IfExpression, SrcSpan { start, end });
             }
 
-            // helpful error on possibly trying to group with ""
+            // Helpful error on possibly trying to group with "(".
             Some((start, Token::LeftParen, _)) => {
                 return parse_error(ParseErrorType::ExprLparStart, SrcSpan { start, end: start });
             }
 
+            // Helpful error when trying to define a constant inside a function.
+            Some((start, Token::Const, end)) => {
+                return parse_error(
+                    ParseErrorType::ConstantInsideFunction,
+                    SrcSpan { start, end },
+                );
+            }
+
             // Boolean negation
             Some((start, Token::Bang, _end)) => {
                 self.advance();

compiler-core/src/parse/error.rs

@@ -115,6 +115,8 @@ pub enum ParseErrorType {
     /// This can happen when there's an empty block in a case clause guard.
     /// For example: `_ if a == {}`
     EmptyGuardBlock,
+    // When the use tries to define a constant inside a function
+    ConstantInsideFunction,
 }
 
 pub(crate) struct ParseErrorDetails {
@@ -637,6 +639,18 @@ utf16_codepoint, utf32_codepoint, signed, unsigned, big, little, native, size, u
                 label_text: "A clause guard block cannot be empty".into(),
                 extra_labels: vec![],
             },
+
+            ParseErrorType::ConstantInsideFunction => ParseErrorDetails {
+                text: wrap(
+                    "All variables are immutable in Gleam, so constants inside \
+functions are not necessary.",
+                ),
+                hint: Some(
+                    "Either move this into the global scope or use `let` binding instead.".into(),
+                ),
+                label_text: "Constants are not allowed inside functions".into(),
+                extra_labels: vec![],
+            },
         }
     }
 }

compiler-core/src/parse/snapshots/gleam_core__parse__tests__constant_inside_function.snap

@@ -0,0 +1,22 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\npub fn main() {\n  const x = 10\n  x\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  const x = 10
+  x
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:3:3
+  │
+3 │   const x = 10
+  │   ^^^^^ Constants are not allowed inside functions
+
+All variables are immutable in Gleam, so constants inside functions are not
+necessary.
+Hint: Either move this into the global scope or use `let` binding instead.

compiler-core/src/parse/tests.rs

@@ -1930,3 +1930,15 @@ fn case_guard_with_empty_block() {
 }"
     );
 }
+
+#[test]
+fn constant_inside_function() {
+    assert_module_error!(
+        "
+pub fn main() {
+  const x = 10
+  x
+}
+"
+    );
+}