Add Deref impl for Spanned

wezm · wezm · commit f682b76aaa3f · 2022-08-16T14:13:00.000+10:00
diff --git a/fathom/src/core/binary.rs b/fathom/src/core/binary.rs
@@ -450,7 +450,7 @@ impl<'arena, 'env, 'data> Context<'arena, 'env, 'data> {
         len: &ArcValue<'arena>,
         elem_format: &ArcValue<'arena>,
     ) -> Result<ArcValue<'arena>, ReadError<'arena>> {
-        let len = match self.elim_context().force(len).inner.as_ref() {
+        let len = match self.elim_context().force(len).as_ref() {
             Value::ConstLit(Const::U8(len, _)) => u64::from(*len),
             Value::ConstLit(Const::U16(len, _)) => u64::from(*len),
             Value::ConstLit(Const::U32(len, _)) => u64::from(*len),
@@ -503,7 +503,7 @@ impl<'arena, 'env, 'data> Context<'arena, 'env, 'data> {
         elem_format: &ArcValue<'arena>,
     ) -> Result<ArcValue<'arena>, ReadError<'arena>> {
         let len_span = len.span();
-        let len = match self.elim_context().force(len).inner.as_ref() {
+        let len = match self.elim_context().force(len).as_ref() {
             Value::ConstLit(Const::U8(len, _)) => Some(usize::from(*len)),
             Value::ConstLit(Const::U16(len, _)) => Some(usize::from(*len)),
             Value::ConstLit(Const::U32(len, _)) => usize::try_from(*len).ok(),
@@ -526,7 +526,7 @@ impl<'arena, 'env, 'data> Context<'arena, 'env, 'data> {
         pos_value: &ArcValue<'arena>,
         elem_format: &ArcValue<'arena>,
     ) -> Result<ArcValue<'arena>, ReadError<'arena>> {
-        let pos = match self.elim_context().force(pos_value).inner.as_ref() {
+        let pos = match self.elim_context().force(pos_value).as_ref() {
             Value::ConstLit(Const::Pos(pos)) => *pos,
             _ => return Err(ReadError::InvalidValue(pos_value.span())),
         };
@@ -544,7 +544,7 @@ impl<'arena, 'env, 'data> Context<'arena, 'env, 'data> {
         format: &ArcValue<'arena>,
         r#ref: &ArcValue<'arena>,
     ) -> Result<ArcValue<'arena>, ReadError<'arena>> {
-        let pos = match self.elim_context().force(r#ref).inner.as_ref() {
+        let pos = match self.elim_context().force(r#ref).as_ref() {
             Value::ConstLit(Const::Ref(pos)) => *pos,
             _ => return Err(ReadError::InvalidValue(r#ref.span())),
         };
diff --git a/fathom/src/core/semantics.rs b/fathom/src/core/semantics.rs
@@ -453,13 +453,13 @@ macro_rules! step {
 // TODO: Should we merge the spans of the input idents to produce the output span?
 macro_rules! const_step {
     ([$($input:ident : $Input:ident),*] => $output:expr) => {
-        step!(_, [$($input),*] => match ($($input.inner.as_ref(),)*) {
+        step!(_, [$($input),*] => match ($($input.as_ref(),)*) {
             ($(Value::ConstLit(Const::$Input($input, ..)),)*) => Spanned::empty(Arc::new(Value::ConstLit($output))),
             _ => return None,
         })
     };
     ([$($input:ident , $style:ident : $Input:ident),*] => $output:expr) => {
-        step!(_, [$($input),*] => match ($($input.inner.as_ref(),)*) {
+        step!(_, [$($input),*] => match ($($input.as_ref(),)*) {
             ($(Value::ConstLit(Const::$Input($input, $style)),)*) => Spanned::empty(Arc::new(Value::ConstLit($output))),
             _ => return None,
         })
@@ -617,10 +617,10 @@ fn prim_step(prim: Prim) -> Option<PrimStep> {
         }),
 
         Prim::Array8Find | Prim::Array16Find | Prim::Array32Find | Prim::Array64Find => {
-            step!(context, [_, _, pred, array] => match array.inner.as_ref() {
+            step!(context, [_, _, pred, array] => match array.as_ref() {
                 Value::ArrayLit(elems) => {
                     for elem in elems {
-                        match context.fun_app(pred.clone(), elem.clone()).inner.as_ref() {
+                        match context.fun_app(pred.clone(), elem.clone()).as_ref() {
                             Value::ConstLit(Const::Bool(true)) => {
                                 // TODO: Is elem.span right here?
                                 return Some(Spanned{ span: elem.span(), inner: Arc::new(Value::prim(Prim::OptionSome, [elem.clone()])) })
@@ -676,7 +676,7 @@ impl<'arena, 'env> ElimContext<'arena, 'env> {
     pub fn force(&self, value: &ArcValue<'arena>) -> ArcValue<'arena> {
         let mut forced_value = value.clone();
         // Attempt to force flexible values until we don't see any more.
-        while let Value::Stuck(Head::FlexibleVar(var), spine) = forced_value.inner.as_ref() {
+        while let Value::Stuck(Head::FlexibleVar(var), spine) = forced_value.as_ref() {
             match self.flexible_exprs.get_global(*var) {
                 // Apply the spine to the solution. This might uncover another
                 // flexible value so we'll continue looping.
@@ -841,7 +841,7 @@ impl<'arena, 'env> ElimContext<'arena, 'env> {
 
     /// Find the representation type of a format description.
     pub fn format_repr(&self, format: &ArcValue<'arena>) -> ArcValue<'arena> {
-        match format.inner.as_ref() {
+        match format.as_ref() {
             Value::FormatRecord(labels, formats) | Value::FormatOverlap(labels, formats) => {
                 Spanned {
                     span: format.span(),
@@ -1044,7 +1044,7 @@ impl<'in_arena, 'out_arena, 'env> QuoteContext<'in_arena, 'out_arena, 'env> {
     pub fn quote(&mut self, value: &ArcValue<'in_arena>) -> Term<'out_arena> {
         let value = self.elim_context().force(value);
         let span = value.span();
-        match value.inner.as_ref() {
+        match value.as_ref() {
             Value::Stuck(head, spine) => {
                 let head_expr = match head {
                     Head::Prim(prim) => Term::Prim(span, *prim),
@@ -1241,7 +1241,7 @@ impl<'arena, 'env> ConversionContext<'arena, 'env> {
         let value0 = self.elim_context().force(value0);
         let value1 = self.elim_context().force(value1);
 
-        match (value0.inner.as_ref(), value1.inner.as_ref()) {
+        match (value0.as_ref(), value1.as_ref()) {
             // `ReportedError`s result from errors that have already been
             // reported, so we prevent them from triggering more errors.
             (Value::Stuck(Head::Prim(Prim::ReportedError), _), _)
diff --git a/fathom/src/source.rs b/fathom/src/source.rs
@@ -36,6 +36,14 @@ impl<T> Spanned<T> {
     }
 }
 
+impl<T> Deref for Spanned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub enum Span {
     Range(ByteRange),
diff --git a/fathom/src/surface/elaboration.rs b/fathom/src/surface/elaboration.rs
@@ -1375,7 +1375,7 @@ impl<'interner, 'arena, 'error> Context<'interner, 'arena, 'error> {
     ) -> core::Term<'arena> {
         let expected_type = self.elim_context().force(expected_type);
 
-        match (surface_term, expected_type.inner.as_ref()) {
+        match (surface_term, expected_type.as_ref()) {
             (Term::Let(range, def_pattern, def_type, def_expr, output_expr), _) => {
                 let (def_pattern, def_type_value) = self.synth_ann_pattern(def_pattern, *def_type);
                 let def_type = self.quote_context(self.scope).quote(&def_type_value); // FIXME: avoid requote if possible?
@@ -1486,7 +1486,7 @@ impl<'interner, 'arena, 'error> Context<'interner, 'arena, 'error> {
                     }
                 };
 
-                let len = match len_value.map(|val| (val.span(), val.inner.as_ref())) {
+                let len = match len_value.map(|val| (val.span(), val.as_ref())) {
                     None => Some(elem_exprs.len() as u64),
                     Some((_, Value::ConstLit(Const::U8(len, _)))) => Some(*len as u64),
                     Some((_, Value::ConstLit(Const::U16(len, _)))) => Some(*len as u64),
@@ -1766,7 +1766,7 @@ impl<'interner, 'arena, 'error> Context<'interner, 'arena, 'error> {
 
                 // Ensure that the head type is a function type
                 let head_type = self.elim_context().force(&head_type);
-                let (head_expr, input_type, output_type) = match head_type.inner.as_ref() {
+                let (head_expr, input_type, output_type) = match head_type.as_ref() {
                     // The simple case - it's easy to see that it is a function type!
                     Value::FunType(_, input_type, output_type) => {
                         (head_expr, input_type.clone(), output_type.clone())
@@ -1879,7 +1879,7 @@ impl<'interner, 'arena, 'error> Context<'interner, 'arena, 'error> {
                 let head_expr_value = self.eval_context().eval(&head_expr);
 
                 let head_type = self.elim_context().force(&head_type);
-                match head_type.inner.as_ref() {
+                match head_type.as_ref() {
                     Value::RecordType(labels, types) => {
                         let mut labels = labels.iter();
                         let mut types = types.clone();
diff --git a/fathom/src/surface/elaboration/unification.rs b/fathom/src/surface/elaboration/unification.rs
@@ -203,7 +203,7 @@ impl<'arena, 'env> Context<'arena, 'env> {
         let value0 = self.elim_context().force(value0);
         let value1 = self.elim_context().force(value1);
 
-        match (value0.inner.as_ref(), value1.inner.as_ref()) {
+        match (value0.as_ref(), value1.as_ref()) {
             // `ReportedError`s result from errors that have already been
             // reported, so we prevent them from triggering more errors.
             (Value::Stuck(Head::Prim(Prim::ReportedError), _), _)
@@ -455,16 +455,14 @@ impl<'arena, 'env> Context<'arena, 'env> {
 
         for elim in spine {
             match elim {
-                Elim::FunApp(input_expr) => {
-                    match self.elim_context().force(input_expr).inner.as_ref() {
-                        Value::Stuck(Head::RigidVar(source_var), spine)
-                            if spine.is_empty() && self.renaming.set_rigid(*source_var) => {}
-                        Value::Stuck(Head::RigidVar(source_var), _) => {
-                            return Err(SpineError::NonLinearSpine(*source_var))
-                        }
-                        _ => return Err(SpineError::NonRigidFunApp),
+                Elim::FunApp(input_expr) => match self.elim_context().force(input_expr).as_ref() {
+                    Value::Stuck(Head::RigidVar(source_var), spine)
+                        if spine.is_empty() && self.renaming.set_rigid(*source_var) => {}
+                    Value::Stuck(Head::RigidVar(source_var), _) => {
+                        return Err(SpineError::NonLinearSpine(*source_var))
                     }
-                }
+                    _ => return Err(SpineError::NonRigidFunApp),
+                },
                 Elim::RecordProj(label) => return Err(SpineError::RecordProj(*label)),
                 Elim::ConstMatch(_) => return Err(SpineError::ConstMatch),
             }
@@ -499,7 +497,7 @@ impl<'arena, 'env> Context<'arena, 'env> {
     ) -> Result<Term<'arena>, RenameError> {
         let val = self.elim_context().force(value);
         let span = val.span();
-        match val.inner.as_ref() {
+        match val.as_ref() {
             Value::Stuck(head, spine) => {
                 let head_expr = match head {
                     Head::Prim(prim) => Term::Prim(span, *prim),

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,14 @@ impl<T> Spanned<T> {`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
	`39`	`+impl<T> Deref for Spanned<T> {`
	`40`	`+ type Target = T;`
	`41`	`+`
	`42`	`+ fn deref(&self) -> &Self::Target {`
	`43`	`+ &self.inner`
	`44`	`+ }`
	`45`	`+}`
	`46`	`+`
`39`	`47`	`#[derive(Debug, Copy, Clone)]`
`40`	`48`	`pub enum Span {`
`41`	`49`	`Range(ByteRange),`