fix: Give tuple fields a span

Fixes gluon-lang/gluon_language-server#40

Author: Marwes

base/src/pos.rs

@@ -319,6 +319,12 @@ pub struct Spanned<T, Pos> {
     pub value: T,
 }
 
+impl<T, Pos> From<(T, Span<Pos>)> for Spanned<T, Pos> {
+    fn from((value, span): (T, Span<Pos>)) -> Self {
+        Spanned { span, value }
+    }
+}
+
 impl<T, Pos> From<T> for Spanned<T, Pos>
 where
     Pos: Default,

base/src/symbol.rs

@@ -9,7 +9,10 @@ use std::{
     sync::Arc,
 };
 
-use crate::ast::{DisplayEnv, IdentEnv};
+use crate::{
+    ast::{DisplayEnv, IdentEnv},
+    pos::{BytePos, Span},
+};
 
 // FIXME Don't have a double indirection (Arc + String)
 /// A symbol uniquely identifies something regardless of its name and which module it originated
@@ -161,6 +164,12 @@ impl From<String> for Symbol {
     }
 }
 
+impl From<(Symbol, Span<BytePos>)> for Symbol {
+    fn from((name, _): (Symbol, Span<BytePos>)) -> Symbol {
+        name
+    }
+}
+
 impl<N> From<SymbolData<N>> for Symbol
 where
     N: Into<NameBuf>,

base/src/types/mod.rs

@@ -1117,19 +1117,19 @@ where
     pub fn tuple<S, I>(symbols: &mut S, elems: I) -> T
     where
         S: ?Sized + IdentEnv<Ident = Id>,
-        T::SpannedId: From<Id>,
+        T::SpannedId: From<(Id, Span<BytePos>)>,
         I: IntoIterator<Item = T>,
-        T: From<(Type<Id, T>, Flags)>,
+        T: From<(Type<Id, T>, Flags)> + HasSpan,
     {
         T::from(Type::tuple_(symbols, elems))
     }
 
     pub fn tuple_<S, I>(symbols: &mut S, elems: I) -> Type<Id, T>
     where
         S: ?Sized + IdentEnv<Ident = Id>,
-        T::SpannedId: From<Id>,
+        T::SpannedId: From<(Id, Span<BytePos>)>,
         I: IntoIterator<Item = T>,
-        T: From<(Type<Id, T>, Flags)>,
+        T: From<(Type<Id, T>, Flags)> + HasSpan,
     {
         NullInterner.tuple_(symbols, elems)
     }
@@ -3583,8 +3583,9 @@ where
     fn tuple<S, I>(&mut self, symbols: &mut S, elems: I) -> T
     where
         S: ?Sized + IdentEnv<Ident = Id>,
-        T::SpannedId: From<Id>,
+        T::SpannedId: From<(Id, Span<BytePos>)>,
         I: IntoIterator<Item = T>,
+        T: HasSpan,
     {
         let t = self.tuple_(symbols, elems);
         self.intern(t)
@@ -3593,12 +3594,13 @@ where
     fn tuple_<S, I>(&mut self, symbols: &mut S, elems: I) -> Type<Id, T>
     where
         S: ?Sized + IdentEnv<Ident = Id>,
-        T::SpannedId: From<Id>,
+        T::SpannedId: From<(Id, Span<BytePos>)>,
+        T: HasSpan,
         I: IntoIterator<Item = T>,
     {
         let empty_row = self.empty_row();
         let elems = self.intern_fields(elems.into_iter().enumerate().map(|(i, typ)| Field {
-            name: symbols.from_str(&format!("_{}", i)).into(),
+            name: (symbols.from_str(&format!("_{}", i)), typ.span()).into(),
             typ,
         }));
         Type::Record(self.extend_row(elems, empty_row))