feat: Use line/column numbers in lambda names

base/src/ast.rs

@@ -857,7 +857,10 @@ pub trait Typed {
         self.try_type_of(env).unwrap()
     }
 
-    fn try_type_of(&self, env: &dyn TypeEnv<Type = ArcType>) -> Result<ArcType<Self::Ident>, String>;
+    fn try_type_of(
+        &self,
+        env: &dyn TypeEnv<Type = ArcType>,
+    ) -> Result<ArcType<Self::Ident>, String>;
 }
 
 impl<Id: Clone> Typed for TypedIdent<Id> {

benches/check.rs

@@ -16,13 +16,13 @@ use gluon::{compiler_pipeline::*, new_vm, Compiler};
 fn typecheck_prelude(b: &mut Bencher) {
     let vm = new_vm();
     let mut compiler = Compiler::new();
-    let MacroValue { expr } = {
-        let text = fs::read_to_string("std/prelude.glu").unwrap();
-        text.expand_macro(&mut compiler, &vm, "std.prelude", &text)
-            .unwrap_or_else(|(_, err)| panic!("{}", err))
-    };
+    let text = fs::read_to_string("std/prelude.glu").unwrap();
+    let MacroValue { expr } = text
+        .expand_macro(&mut compiler, &vm, "std.prelude", &text)
+        .unwrap_or_else(|(_, err)| panic!("{}", err));
     b.iter(|| {
-        let result = MacroValue { expr: expr.clone() }.typecheck(&mut compiler, &vm, "<top>", "");
+        let result =
+            MacroValue { expr: expr.clone() }.typecheck(&mut compiler, &vm, "<top>", &text);
         if let Err(ref err) = result {
             println!("{}", err);
             assert!(false);
@@ -45,13 +45,13 @@ fn clone_prelude(b: &mut Bencher) {
 fn typecheck_24(b: &mut Bencher) {
     let vm = new_vm();
     let mut compiler = Compiler::new();
-    let MacroValue { expr } = {
-        let text = fs::read_to_string("examples/24.glu").unwrap();
-        text.expand_macro(&mut compiler, &vm, "examples.24", &text)
-            .unwrap_or_else(|(_, err)| panic!("{}", err))
-    };
+    let text = fs::read_to_string("examples/24.glu").unwrap();
+    let MacroValue { expr } = text
+        .expand_macro(&mut compiler, &vm, "examples.24", &text)
+        .unwrap_or_else(|(_, err)| panic!("{}", err));
     b.iter(|| {
-        let result = MacroValue { expr: expr.clone() }.typecheck(&mut compiler, &vm, "<top>", "");
+        let result =
+            MacroValue { expr: expr.clone() }.typecheck(&mut compiler, &vm, "<top>", &text);
         if let Err(ref err) = result {
             println!("{}", err);
             assert!(false);
@@ -63,11 +63,10 @@ fn typecheck_24(b: &mut Bencher) {
 fn typecheck_file(b: &mut Bencher, file: &str) {
     let vm = new_vm();
     let mut compiler = Compiler::new();
-    let reparsed = {
-        let text = fs::read_to_string(file).unwrap();
-        text.reparse_infix(&mut compiler, &vm, &base::filename_to_module(file), &text)
-            .unwrap_or_else(|(_, err)| panic!("{}", err))
-    };
+    let text = fs::read_to_string(file).unwrap();
+    let reparsed = text
+        .reparse_infix(&mut compiler, &vm, &base::filename_to_module(file), &text)
+        .unwrap_or_else(|(_, err)| panic!("{}", err));
     let InfixReparsed {
         metadata,
         metadata_map,
@@ -80,7 +79,7 @@ fn typecheck_file(b: &mut Bencher, file: &str) {
             expr: expr.clone(),
         },
         |input| {
-            let result = input.typecheck(&mut compiler, &vm, "<top>", "");
+            let result = input.typecheck(&mut compiler, &vm, "<top>", &text);
             if let Err(ref err) = result {
                 println!("{}", err);
                 assert!(false);

check/src/rename.rs

@@ -6,6 +6,7 @@ use crate::base::{
     fnv::FnvMap,
     pos::{self, ByteOffset, BytePos, Span},
     scoped_map::ScopedMap,
+    source::Source,
     symbol::{Symbol, SymbolModule},
     types::Type,
 };
@@ -14,19 +15,24 @@ struct Environment {
     stack: ScopedMap<Symbol, (Symbol, Span<BytePos>)>,
 }
 
-pub fn rename(symbols: &mut SymbolModule, expr: &mut SpannedExpr<Symbol>) {
+pub fn rename<'s>(
+    source: &'s (dyn Source + 's),
+    symbols: &mut SymbolModule,
+    expr: &mut SpannedExpr<Symbol>,
+) {
     enum TailCall {
         TailCall,
         Return,
     }
 
-    struct RenameVisitor<'a: 'b, 'b> {
+    struct RenameVisitor<'a: 'b, 'b, 's> {
+        source: &'s (dyn Source + 's),
         symbols: &'b mut SymbolModule<'a>,
         seen_symbols: FnvMap<Symbol, u32>,
         env: Environment,
     }
 
-    impl<'a, 'b> RenameVisitor<'a, 'b> {
+    impl<'a, 'b, 's> RenameVisitor<'a, 'b, 's> {
         fn new_pattern(&mut self, pattern: &mut ast::SpannedPattern<Symbol>) {
             match pattern.value {
                 Pattern::Record {
@@ -205,6 +211,10 @@ pub fn rename(symbols: &mut SymbolModule, expr: &mut SpannedExpr<Symbol>) {
                     return TailCall::TailCall;
                 }
                 Expr::Lambda(ref mut lambda) => {
+                    let location = self.source.location(expr.span.start()).unwrap_or_else(|| ice!("Lambda without source location"));
+                    let name = format!("{}.lambda:{}_{}", self.symbols.module(), location.line.number(), location.column.number());
+                    lambda.id.name = self.symbols.symbol(name);
+
                     self.env.stack.enter_scope();
 
                     for arg in &mut lambda.args {
@@ -264,7 +274,7 @@ pub fn rename(symbols: &mut SymbolModule, expr: &mut SpannedExpr<Symbol>) {
         }
     }
 
-    impl<'a, 'b, 'c> MutVisitor<'c> for RenameVisitor<'a, 'b> {
+    impl<'a, 'b, 'c, 's> MutVisitor<'c> for RenameVisitor<'a, 'b, 's> {
         type Ident = Symbol;
 
         fn visit_pattern(&mut self, pattern: &mut ast::SpannedPattern<Symbol>) {
@@ -325,6 +335,7 @@ pub fn rename(symbols: &mut SymbolModule, expr: &mut SpannedExpr<Symbol>) {
     }
 
     let mut visitor = RenameVisitor {
+        source,
         symbols: symbols,
         seen_symbols: Default::default(),
         env: Environment {

check/src/typecheck.rs

@@ -1008,8 +1008,6 @@ impl<'a> Typecheck<'a> {
                 Ok(TailCall::Type(ModType::wobbly(array_type)))
             }
             Expr::Lambda(ref mut lambda) => {
-                let loc = format!("{}.lambda:{}", self.symbols.module(), expr.span.start());
-                lambda.id.name = self.symbols.symbol(loc);
                 let level = self.subs.var_id();
                 let function_type = expected_type
                     .take()
@@ -1912,11 +1910,6 @@ impl<'a> Typecheck<'a> {
                     resolved_types[i].concrete.clone()
                 };
                 self.typecheck_let_pattern(&mut bind.name, typ);
-                if let Expr::Lambda(ref mut lambda) = bind.expr.value {
-                    if let Pattern::Ident(ref name) = bind.name.value {
-                        lambda.id.name = name.name.clone();
-                    }
-                }
             }
         }
 

check/tests/support/mod.rs

@@ -201,7 +201,9 @@ pub fn typecheck_expr_expected(
     let interner = get_local_interner();
     let mut interner = interner.borrow_mut();
 
+    let source = codespan::FileMap::new("test".into(), text.to_string());
     rename::rename(
+        &source,
         &mut SymbolModule::new("test".into(), &mut interner),
         &mut expr,
     );
@@ -242,7 +244,9 @@ pub fn typecheck_partial_expr(
     let interner = get_local_interner();
     let mut interner = interner.borrow_mut();
 
+    let source = codespan::FileMap::new("test".into(), text.to_string());
     rename::rename(
+        &source,
         &mut SymbolModule::new("test".into(), &mut interner),
         &mut expr,
     );

completion/tests/support/mod.rs

@@ -129,7 +129,11 @@ pub fn typecheck_expr_expected(
     let interner = get_local_interner();
     let mut interner = interner.borrow_mut();
 
+    let mut code_map = codespan::CodeMap::new();
+    let source = code_map.add_filemap("test".into(), text.into());
+
     rename::rename(
+        &*source,
         &mut SymbolModule::new("test".into(), &mut interner),
         &mut expr,
     );
@@ -145,14 +149,7 @@ pub fn typecheck_expr_expected(
 
     let result = tc.typecheck_expr_expected(&mut expr, expected);
 
-    (
-        expr,
-        result.map_err(|err| {
-            let mut source = codespan::CodeMap::new();
-            source.add_filemap(codespan::FileName::virtual_("test"), text.into());
-            InFile::new(source, err)
-        }),
-    )
+    (expr, result.map_err(|err| InFile::new(code_map, err)))
 }
 
 pub fn typecheck_expr(
@@ -179,7 +176,11 @@ pub fn typecheck_partial_expr(
     let interner = get_local_interner();
     let mut interner = interner.borrow_mut();
 
+    let mut code_map = codespan::CodeMap::new();
+    let source = code_map.add_filemap("test".into(), text.into());
+
     rename::rename(
+        &*source,
         &mut SymbolModule::new("test".into(), &mut interner),
         &mut expr,
     );
@@ -196,14 +197,7 @@ pub fn typecheck_partial_expr(
 
     let result = tc.typecheck_expr(&mut expr);
 
-    (
-        expr,
-        result.map_err(|err| {
-            let mut source = codespan::CodeMap::new();
-            source.add_filemap("test".into(), text.into());
-            InFile::new(source, err)
-        }),
-    )
+    (expr, result.map_err(|err| InFile::new(code_map, err)))
 }
 
 pub fn typ(s: &str) -> ArcType {

src/compiler_pipeline.rs

@@ -256,10 +256,11 @@ where
         compiler: &mut Compiler,
         _thread: &Thread,
         file: &str,
-        _expr_str: &str,
+        expr_str: &str,
     ) -> SalvageResult<Renamed<Self::Expr>> {
+        let source = compiler.get_or_insert_filemap(file, expr_str);
         let mut symbols = SymbolModule::new(String::from(file), &mut compiler.symbols);
-        rename::rename(&mut symbols, &mut self.expr.borrow_mut());
+        rename::rename(&*source, &mut symbols, &mut self.expr.borrow_mut());
         Ok(Renamed { expr: self.expr })
     }
 }

src/import.rs

@@ -495,9 +495,10 @@ where
                     format!("@{}", filename_to_module(filename))
                 }
                 _ => {
-                    return Err(
-                        Error::String("Expected a string literal or path to import".into()).into(),
-                    );
+                    return Err(Error::String(
+                        "Expected a string literal or path to import".into(),
+                    )
+                    .into());
                 }
             };
             Ok(modulename)

src/lib.rs

@@ -218,6 +218,16 @@ impl State {
             })
     }
 
+    fn get_or_insert_filemap<S>(&mut self, file: &str, source: S) -> Arc<codespan::FileMap>
+    where
+        S: AsRef<str> + Into<String>,
+    {
+        if let Some(i) = self.index_map.get(file) {
+            return self.code_map.find_file(*i).unwrap().clone();
+        }
+        self.add_filemap(file, source)
+    }
+
     pub fn get_filemap(&self, file: &str) -> Option<&Arc<codespan::FileMap>> {
         self.index_map
             .get(file)
@@ -352,6 +362,13 @@ impl Compiler {
         self.state().update_filemap(file, source)
     }
 
+    pub(crate) fn get_or_insert_filemap<S>(&self, file: &str, source: S) -> Arc<codespan::FileMap>
+    where
+        S: AsRef<str> + Into<String>,
+    {
+        self.state().get_or_insert_filemap(file, source)
+    }
+
     pub fn get_filemap(&self, file: &str) -> Option<Arc<codespan::FileMap>> {
         self.state().get_filemap(file).cloned()
     }