Add filepath to errors

Author: lpil

compiler-core/src/javascript.rs

@@ -43,13 +43,15 @@ pub enum JavaScriptCodegenTarget {
 pub struct Generator<'a> {
     line_numbers: &'a LineNumbers,
     module: &'a TypedModule,
-    project_root: &'a Utf8Path,
     tracker: UsageTracker,
     module_scope: im::HashMap<EcoString, usize>,
     current_module_name_segments_count: usize,
     target_support: TargetSupport,
     typescript: TypeScriptDeclarations,
     stdlib_package: StdlibPackage,
+    /// Relative path to the module, surrounded in `"`s to make it a string, and with `\`s escaped
+    /// to `\\`.
+    src_path: EcoString,
 }
 
 impl<'a> Generator<'a> {
@@ -66,11 +68,18 @@ impl<'a> Generator<'a> {
         } = config;
         let current_module_name_segments_count = module.name.split('/').count();
 
+        let src_path = &module.type_info.src_path;
+        let src_path = src_path
+            .strip_prefix(project_root)
+            .unwrap_or(src_path)
+            .as_str();
+        let src_path = eco_format!("\"{src_path}\"").replace("\\", "\\\\");
+
         Self {
             current_module_name_segments_count,
             line_numbers,
-            project_root,
             module,
+            src_path,
             tracker: UsageTracker::default(),
             module_scope: Default::default(),
             target_support,
@@ -81,7 +90,7 @@ impl<'a> Generator<'a> {
 
     fn type_reference(&self) -> Document<'a> {
         if self.typescript == TypeScriptDeclarations::None {
-            return "".to_doc();
+            return nil();
         }
 
         // Get the name of the module relative the directory (similar to basename)
@@ -97,8 +106,6 @@ impl<'a> Generator<'a> {
     }
 
     pub fn compile(&mut self) -> Output<'a> {
-        let type_reference = self.type_reference();
-
         // Determine what JavaScript imports we need to generate
         let mut imports = self.collect_imports();
 
@@ -217,52 +224,66 @@ impl<'a> Generator<'a> {
             self.register_prelude_usage(&mut imports, "sizedFloat", None);
         }
 
-        let echo = if self.tracker.echo_used {
-            if StdlibPackage::Present == self.stdlib_package {
-                self.register_import(
-                    &mut imports,
-                    "gleam_stdlib",
-                    "dict",
-                    &Some((
-                        AssignName::Variable("stdlib$dict".into()),
-                        SrcSpan::default(),
-                    )),
-                    &[],
-                );
-            }
-            self.register_prelude_usage(&mut imports, "BitArray", Some("$BitArray"));
-            self.register_prelude_usage(&mut imports, "List", Some("$List"));
-            self.register_prelude_usage(&mut imports, "UtfCodepoint", Some("$UtfCodepoint"));
-            docvec![line(), std::include_str!("../templates/echo.mjs"), line()]
-        } else {
-            nil()
-        };
+        let echo_definition = self.echo_definition(&mut imports);
+        let type_reference = self.type_reference();
+        let filepath_definition = self.filepath_definition();
 
         // Put it all together
 
         if imports.is_empty() && statements.is_empty() {
-            Ok(docvec![type_reference, "export {}", line(), echo])
+            Ok(docvec![
+                type_reference,
+                filepath_definition,
+                "export {}",
+                line(),
+                echo_definition
+            ])
         } else if imports.is_empty() {
             statements.push(line());
-            Ok(docvec![type_reference, statements, echo])
+            Ok(docvec![
+                type_reference,
+                filepath_definition,
+                statements,
+                echo_definition
+            ])
         } else if statements.is_empty() {
             Ok(docvec![
                 type_reference,
                 imports.into_doc(JavaScriptCodegenTarget::JavaScript),
-                echo,
+                filepath_definition,
+                echo_definition,
             ])
         } else {
             Ok(docvec![
                 type_reference,
                 imports.into_doc(JavaScriptCodegenTarget::JavaScript),
                 line(),
+                filepath_definition,
                 statements,
                 line(),
-                echo
+                echo_definition
             ])
         }
     }
 
+    fn echo_definition(&mut self, imports: &mut Imports<'a>) -> Document<'a> {
+        if !self.tracker.echo_used {
+            return nil();
+        }
+
+        if StdlibPackage::Present == self.stdlib_package {
+            let value = Some((
+                AssignName::Variable("stdlib$dict".into()),
+                SrcSpan::default(),
+            ));
+            self.register_import(imports, "gleam_stdlib", "dict", &value, &[]);
+        }
+        self.register_prelude_usage(imports, "BitArray", Some("$BitArray"));
+        self.register_prelude_usage(imports, "List", Some("$List"));
+        self.register_prelude_usage(imports, "UtfCodepoint", Some("$UtfCodepoint"));
+        docvec![line(), std::include_str!("../templates/echo.mjs"), line()]
+    }
+
     fn register_prelude_usage(
         &self,
         imports: &mut Imports<'a>,
@@ -541,8 +562,7 @@ impl<'a> Generator<'a> {
 
         let mut generator = expression::Generator::new(
             self.module.name.clone(),
-            &self.module.type_info.src_path,
-            self.project_root,
+            self.src_path.clone(),
             self.line_numbers,
             "".into(),
             vec![],
@@ -577,8 +597,7 @@ impl<'a> Generator<'a> {
             .collect();
         let mut generator = expression::Generator::new(
             self.module.name.clone(),
-            &self.module.type_info.src_path,
-            self.project_root,
+            self.src_path.clone(),
             self.line_numbers,
             name.clone(),
             argument_names,
@@ -643,6 +662,14 @@ impl<'a> Generator<'a> {
             }
         }
     }
+
+    fn filepath_definition(&self) -> Document<'a> {
+        if !self.tracker.make_error_used {
+            return nil();
+        }
+
+        docvec!["const FILEPATH = ", self.src_path.clone(), ';', lines(2)]
+    }
 }
 
 #[derive(Debug)]

compiler-core/src/javascript/expression.rs

@@ -124,8 +124,7 @@ impl CurrentFunction {
 #[derive(Debug)]
 pub(crate) struct Generator<'module, 'ast> {
     module_name: EcoString,
-    src_path: &'module Utf8Path,
-    project_root: &'module Utf8Path,
+    src_path: EcoString,
     line_numbers: &'module LineNumbers,
     function_name: EcoString,
     function_arguments: Vec<Option<&'module EcoString>>,
@@ -175,8 +174,7 @@ impl<'module, 'a> Generator<'module, 'a> {
     #[allow(clippy::too_many_arguments)] // TODO: FIXME
     pub fn new(
         module_name: EcoString,
-        src_path: &'module Utf8Path,
-        project_root: &'module Utf8Path,
+        src_path: EcoString,
         line_numbers: &'module LineNumbers,
         function_name: EcoString,
         function_arguments: Vec<Option<&'module EcoString>>,
@@ -198,7 +196,6 @@ impl<'module, 'a> Generator<'module, 'a> {
             tracker,
             module_name,
             src_path,
-            project_root,
             line_numbers,
             function_name,
             function_arguments,
@@ -1666,6 +1663,7 @@ impl<'module, 'a> Generator<'module, 'a> {
             "throw makeError",
             wrap_args([
                 string(error_name),
+                "FILEPATH".to_doc(),
                 module,
                 line,
                 function,
@@ -1695,18 +1693,9 @@ impl<'module, 'a> Generator<'module, 'a> {
     fn echo(&mut self, expression: Document<'a>, location: &'a SrcSpan) -> Output<'a> {
         self.tracker.echo_used = true;
 
-        let relative_path = self
-            .src_path
-            .strip_prefix(self.project_root)
-            .unwrap_or(self.src_path)
-            .as_str()
-            .replace("\\", "\\\\");
-
-        let relative_path_doc = EcoString::from(relative_path).to_doc();
-
         let echo_argument = call_arguments(vec![
             Ok(expression),
-            Ok(relative_path_doc.surround("\"", "\"")),
+            Ok(self.src_path.clone().to_doc()),
             Ok(self.line_numbers.line_number(location.start).to_doc()),
         ])?;
         Ok(self.wrap_return(docvec!["echo", echo_argument]))

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_binary_operation.snap

@@ -15,12 +15,15 @@ pub fn main() {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 export function main() {
   let x = true;
 
   if (!(x || false)) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       4,
       "main",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_binary_operation2.snap

@@ -14,10 +14,13 @@ pub fn eq(a, b) {
 ----- COMPILED JAVASCRIPT
 import { makeError, isEqual } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 export function eq(a, b) {
   if (!(isEqual(a, b))) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       3,
       "eq",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_binary_operation3.snap

@@ -14,11 +14,14 @@ pub fn assert_answer(x) {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 export function assert_answer(x) {
   let $ = 42;
   if (!(x === $)) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       3,
       "assert_answer",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_binary_operator_with_side_effects.snap

@@ -19,6 +19,8 @@ pub fn go(x) {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 function wibble(a, b) {
   let result = a + b;
   return result === 10;
@@ -29,6 +31,7 @@ export function go(x) {
     if (!wibble(1, 4)) {
       throw makeError(
         "assert",
+        FILEPATH,
         "my/mod",
         8,
         "go",
@@ -47,6 +50,7 @@ export function go(x) {
   } else {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       8,
       "go",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_binary_operator_with_side_effects2.snap

@@ -19,6 +19,8 @@ pub fn go(x) {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 function wibble(a, b) {
   let result = a + b;
   return result === 10;
@@ -29,6 +31,7 @@ export function go(x) {
     if (!wibble(4, 6)) {
       throw makeError(
         "assert",
+        FILEPATH,
         "my/mod",
         8,
         "go",
@@ -47,6 +50,7 @@ export function go(x) {
   } else {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       8,
       "go",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_function_call.snap

@@ -18,6 +18,8 @@ pub fn main() {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 function bool() {
   return true;
 }
@@ -26,6 +28,7 @@ export function main() {
   if (!bool()) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       7,
       "main",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_function_call2.snap

@@ -18,6 +18,8 @@ pub fn go(x) {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 function and(a, b) {
   return a && b;
 }
@@ -26,6 +28,7 @@ export function go(x) {
   if (!and(true, x)) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       7,
       "go",

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__assert__assert_literal.snap

@@ -14,10 +14,13 @@ pub fn main() {
 ----- COMPILED JAVASCRIPT
 import { makeError } from "../gleam.mjs";
 
+const FILEPATH = "src/module.gleam";
+
 export function main() {
   if (!false) {
     throw makeError(
       "assert",
+      FILEPATH,
       "my/mod",
       3,
       "main",