Move Spanned into source module

Author: wezm

fathom/src/core/binary.rs

@@ -7,10 +7,10 @@ use std::fmt::Debug;
 use std::slice::SliceIndex;
 use std::sync::Arc;
 
-use crate::core::semantics::{self, ArcValue, Elim, Head, Spanned, Value};
+use crate::core::semantics::{self, ArcValue, Elim, Head, Value};
 use crate::core::{Const, Prim, UIntStyle};
 use crate::env::{EnvLen, SliceEnv};
-use crate::source::Span;
+use crate::source::{Span, Spanned};
 
 #[derive(Clone, Debug)]
 pub enum ReadError<'arena> {

fathom/src/core/semantics.rs

@@ -8,44 +8,13 @@ use std::sync::Arc;
 use crate::alloc::SliceVec;
 use crate::core::{Const, EntryInfo, Prim, Term, UIntStyle};
 use crate::env::{EnvLen, GlobalVar, SharedEnv, SliceEnv};
-use crate::source::Span;
+use crate::source::{Span, Spanned};
 use crate::StringId;
 
 /// Atomically reference counted values. We use reference counting to increase
 /// the amount of sharing we can achieve during evaluation.
 pub type ArcValue<'arena> = Spanned<Arc<Value<'arena>>>;
 
-#[derive(Debug, Clone)]
-pub struct Spanned<T> {
-    pub span: Span,
-    pub inner: T,
-}
-
-impl<T> Spanned<T> {
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn empty(inner: T) -> Self {
-        Spanned {
-            span: Span::Empty,
-            inner,
-        }
-    }
-
-    /// Merge the supplied span and the span of value and return value wrapped in that span.
-    pub fn merge(span: Span, other: Spanned<T>) -> Spanned<T> {
-        let Spanned {
-            span: other_span,
-            inner,
-        } = other;
-        Spanned {
-            span: span.merge(&other_span),
-            inner,
-        }
-    }
-}
-
 impl<'arena> ArcValue<'arena> {
     pub fn match_prim_spine(&self) -> Option<(Prim, &[Elim<'arena>])> {
         self.inner.match_prim_spine()

fathom/src/driver.rs

@@ -7,8 +7,7 @@ use std::path::Path;
 
 use crate::core::binary;
 use crate::core::binary::{BufferError, ReadError};
-use crate::core::semantics::Spanned;
-use crate::source::{ByteRange, FileId, Span};
+use crate::source::{ByteRange, FileId, Span, Spanned};
 use crate::surface::{self, elaboration};
 use crate::{StringInterner, BUG_REPORT_URL};
 

fathom/src/source.rs

@@ -1,9 +1,41 @@
+use std::ops::Deref;
+
 ///! Types related to source files.
 
 /// File id.
 pub type FileId = usize; // TODO: use wrapper struct
 
-// TODO: Better name?
+#[derive(Debug, Clone)]
+pub struct Spanned<T> {
+    pub span: Span,
+    pub inner: T,
+}
+
+impl<T> Spanned<T> {
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    pub fn empty(inner: T) -> Self {
+        Spanned {
+            span: Span::Empty,
+            inner,
+        }
+    }
+
+    /// Merge the supplied span and the span of value and return value wrapped in that span.
+    pub fn merge(span: Span, other: Spanned<T>) -> Spanned<T> {
+        let Spanned {
+            span: other_span,
+            inner,
+        } = other;
+        Spanned {
+            span: span.merge(&other_span),
+            inner,
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub enum Span {
     Range(ByteRange),
@@ -14,6 +46,13 @@ impl Span {
     pub const fn fixme() -> Span {
         Span::Empty
     }
+
+    pub fn merge(&self, other: &Span) -> Span {
+        match (self, other) {
+            (Span::Range(a), Span::Range(b)) => a.merge(b).map(Span::Range).unwrap_or(Span::Empty),
+            (_, _) => Span::Empty,
+        }
+    }
 }
 
 impl From<&ByteRange> for Span {

fathom/src/surface/elaboration.rs

@@ -26,10 +26,10 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use crate::alloc::SliceVec;
-use crate::core::semantics::{self, ArcValue, Closure, Head, Spanned, Telescope, Value};
+use crate::core::semantics::{self, ArcValue, Closure, Head, Telescope, Value};
 use crate::core::{self, binary, Const, Prim, UIntStyle};
 use crate::env::{self, EnvLen, GlobalVar, SharedEnv, SliceEnv, UniqueEnv};
-use crate::source::{ByteRange, Span};
+use crate::source::{ByteRange, Span, Spanned};
 use crate::surface::elaboration::reporting::Message;
 use crate::surface::{distillation, pretty, BinOp, FormatField, Item, Module, Pattern, Term};
 use crate::{StringId, StringInterner};

fathom/src/surface/elaboration/unification.rs

@@ -20,10 +20,11 @@ use std::sync::Arc;
 
 use crate::alloc::SliceVec;
 use crate::core::semantics::{
-    self, ArcValue, Closure, Elim, Head, Spanned, SplitBranches, Telescope, Value,
+    self, ArcValue, Closure, Elim, Head, SplitBranches, Telescope, Value,
 };
 use crate::core::{Prim, Term};
 use crate::env::{EnvLen, GlobalVar, LocalVar, SharedEnv, SliceEnv, UniqueEnv};
+use crate::source::Spanned;
 use crate::StringId;
 
 /// Errors encountered during unification.