Split Spanned<T> from Span and expose fields

Spanned<T> wraps a value with a Span.
Public fields enable destructuring in pattern matches.

1 files changed, 27 insertions, 40 deletions

diff --git a/compiler/src/span.rs b/compiler/src/span.rs
index 0644c1c..369c58c 100644
--- a/compiler/src/span.rs
+++ b/compiler/src/span.rs
@@ -1,61 +1,48 @@
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Pos {
-    line: usize,
-    column: usize,
-    cursor: usize,
+    pub line: usize,
+    pub column: usize,
+    pub offset: usize,
 }
 
 impl Pos {
-    pub fn new(line: usize, column: usize, cursor: usize) -> Self {
+    pub fn new(line: usize, column: usize, offset: usize) -> Self {
         Self {
             line,
             column,
-            cursor,
+            offset,
         }
     }
-
-    pub fn line(self) -> usize {
-        self.line
-    }
-
-    pub fn column(self) -> usize {
-        self.column
-    }
-
-    pub fn cursor(self) -> usize {
-        self.cursor
-    }
 }
 
-#[derive(Clone, Debug)]
-pub struct Span<T> {
-    inner: T,
-    start: Pos,
-    end: Pos,
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Span {
+    pub start: Pos,
+    pub end: Pos,
 }
 
-impl<T> Span<T> {
-    pub fn new(inner: T, start: Pos, end: Pos) -> Self {
-        Self { inner, start, end }
-    }
-
-    pub fn inner(&self) -> &T {
-        &self.inner
-    }
-
-    pub fn inner_mut(&mut self) -> &mut T {
-        &mut self.inner
+impl Span {
+    pub fn new(start: Pos, end: Pos) -> Self {
+        Self { start, end }
     }
+}
 
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
+#[derive(Clone, Copy, Debug)]
+pub struct Spanned<T> {
+    pub inner: T,
+    pub span: Span,
+}
 
-    pub fn start(&self) -> Pos {
-        self.start
+impl<T> Spanned<T> {
+    pub fn new(inner: T, span: Span) -> Self {
+        Self { inner, span }
     }
 
-    pub fn end(&self) -> Pos {
-        self.end
+    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Spanned<U> {
+        let Self { inner, span } = self;
+        Spanned {
+            inner: f(inner),
+            span,
+        }
     }
 }