From 0e4f4c5af67b4075174ace5a1c7800dae60a9d11 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 10:52:57 +0000
Subject: Move Span definition to its own file

And prepare for more variants
---
 dhall_syntax/src/core/expr.rs | 35 ----------------------------------
 dhall_syntax/src/core/mod.rs  |  2 ++
 dhall_syntax/src/core/span.rs | 44 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 35 deletions(-)
 create mode 100644 dhall_syntax/src/core/span.rs

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 2ad3ba8..70ce1dc 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -1,4 +1,3 @@
-use std::rc::Rc;
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::visitor::{self, ExprFMutVisitor, ExprFVisitor};
@@ -15,40 +14,6 @@ pub fn trivial_result<T>(x: Result<T, !>) -> T {
     }
 }
 
-/// A location in the source text
-#[derive(Debug, Clone)]
-pub struct Span {
-    input: Rc<str>,
-    /// # Safety
-    ///
-    /// Must be a valid character boundary index into `input`.
-    start: usize,
-    /// # Safety
-    ///
-    /// Must be a valid character boundary index into `input`.
-    end: usize,
-}
-
-impl Span {
-    pub(crate) fn make(input: Rc<str>, sp: pest::Span) -> Self {
-        Span {
-            input,
-            start: sp.start(),
-            end: sp.end(),
-        }
-    }
-    /// Takes the union of the two spans. Assumes that the spans come from the same input.
-    /// This will also capture any input between the spans.
-    pub fn union(&self, other: &Span) -> Self {
-        use std::cmp::{max, min};
-        Span {
-            input: self.input.clone(),
-            start: min(self.start, other.start),
-            end: max(self.start, other.start),
-        }
-    }
-}
-
 /// Double with bitwise equality
 #[derive(Debug, Copy, Clone)]
 pub struct NaiveDouble(f64);
diff --git a/dhall_syntax/src/core/mod.rs b/dhall_syntax/src/core/mod.rs
index fe2c0be..66bf229 100644
--- a/dhall_syntax/src/core/mod.rs
+++ b/dhall_syntax/src/core/mod.rs
@@ -4,6 +4,8 @@ mod import;
 pub use import::*;
 mod label;
 pub use label::*;
+mod span;
+pub use span::*;
 mod text;
 pub use text::*;
 pub mod context;
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
new file mode 100644
index 0000000..ad5a3a9
--- /dev/null
+++ b/dhall_syntax/src/core/span.rs
@@ -0,0 +1,44 @@
+use std::rc::Rc;
+
+/// A location in the source text
+#[derive(Debug, Clone)]
+pub struct ParsedSpan {
+    input: Rc<str>,
+    /// # Safety
+    ///
+    /// Must be a valid character boundary index into `input`.
+    start: usize,
+    /// # Safety
+    ///
+    /// Must be a valid character boundary index into `input`.
+    end: usize,
+}
+
+/// A location in the source text
+#[derive(Debug, Clone)]
+pub enum Span {
+    Parsed(ParsedSpan),
+}
+
+impl Span {
+    pub(crate) fn make(input: Rc<str>, sp: pest::Span) -> Self {
+        Span::Parsed(ParsedSpan {
+            input,
+            start: sp.start(),
+            end: sp.end(),
+        })
+    }
+    /// Takes the union of the two spans. Assumes that the spans come from the same input.
+    /// This will also capture any input between the spans.
+    pub fn union(&self, other: &Span) -> Self {
+        use std::cmp::{max, min};
+        use Span::*;
+        match (self, other) {
+            (Parsed(x), Parsed(y)) => Span::Parsed(ParsedSpan {
+                input: x.input.clone(),
+                start: min(x.start, y.start),
+                end: max(x.start, y.start),
+            }),
+        }
+    }
+}
-- 
cgit v1.3.1


From a8cb6926cbafb2ac806f7bec27a29b0528ed5056 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 10:53:29 +0000
Subject: Fix typo

---
 dhall_syntax/src/core/span.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index ad5a3a9..f0eb89a 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -37,7 +37,7 @@ impl Span {
             (Parsed(x), Parsed(y)) => Span::Parsed(ParsedSpan {
                 input: x.input.clone(),
                 start: min(x.start, y.start),
-                end: max(x.start, y.start),
+                end: max(x.end, y.end),
             }),
         }
     }
-- 
cgit v1.3.1


From b68c3af578d1f6b0d1e32e7d88ef57774fb468d8 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 11:20:32 +0000
Subject: Capture absence of span in Span itself

---
 dhall/src/core/valuef.rs      |  3 ++-
 dhall/src/phase/binary.rs     | 10 ++++++++--
 dhall/src/phase/typecheck.rs  |  6 +++++-
 dhall_syntax/src/core/expr.rs | 18 ++++--------------
 dhall_syntax/src/core/span.rs | 13 +++++++++++--
 dhall_syntax/src/parser.rs    | 14 +++++---------
 6 files changed, 35 insertions(+), 29 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/core/valuef.rs b/dhall/src/core/valuef.rs
index 4e457e6..e5d0807 100644
--- a/dhall/src/core/valuef.rs
+++ b/dhall/src/core/valuef.rs
@@ -1,12 +1,13 @@
 use std::collections::HashMap;
 
 use dhall_syntax::{
-    rc, Builtin, Const, ExprF, Integer, InterpolatedTextContents, Label,
+    Builtin, Const, ExprF, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural,
 };
 
 use crate::core::value::{ToExprOptions, Value};
 use crate::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
+use crate::phase::typecheck::rc;
 use crate::phase::{Normalized, NormalizedExpr};
 
 /// A semantic value. Subexpressions are Values, which are partially evaluated expressions that are
diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs
index 8c98f77..b4f18da 100644
--- a/dhall/src/phase/binary.rs
+++ b/dhall/src/phase/binary.rs
@@ -5,8 +5,9 @@ use std::vec;
 
 use dhall_syntax::map::DupTreeMap;
 use dhall_syntax::{
-    rc, Expr, ExprF, FilePath, FilePrefix, Hash, Import, ImportLocation,
-    ImportMode, Integer, InterpolatedText, Label, Natural, Scheme, URL, V,
+    Expr, ExprF, FilePath, FilePrefix, Hash, Import, ImportLocation,
+    ImportMode, Integer, InterpolatedText, Label, Natural, RawExpr, Scheme,
+    Span, URL, V,
 };
 
 use crate::error::{DecodeError, EncodeError};
@@ -24,6 +25,11 @@ pub(crate) fn encode<E>(expr: &Expr<E>) -> Result<Vec<u8>, EncodeError> {
         .map_err(|e| EncodeError::CBORError(e))
 }
 
+// Should probably rename this
+pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
+    Expr::new(x, Span::Decoded)
+}
+
 fn cbor_value_to_dhall(data: &cbor::Value) -> Result<DecodedExpr, DecodeError> {
     use cbor::Value::*;
     use dhall_syntax::{BinOp, Builtin, Const};
diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs
index 9013c1f..4d8c7d3 100644
--- a/dhall/src/phase/typecheck.rs
+++ b/dhall/src/phase/typecheck.rs
@@ -2,7 +2,7 @@ use std::cmp::max;
 use std::collections::HashMap;
 
 use dhall_syntax::{
-    rc, Builtin, Const, Expr, ExprF, InterpolatedTextContents, Label,
+    Builtin, Const, Expr, ExprF, InterpolatedTextContents, Label, RawExpr, Span,
 };
 
 use crate::core::context::TypecheckContext;
@@ -142,6 +142,10 @@ pub(crate) fn const_to_value(c: Const) -> Value {
     }
 }
 
+pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
+    Expr::new(x, Span::Artificial)
+}
+
 // Ad-hoc macro to help construct the types of builtins
 macro_rules! make_type {
     (Type) => { ExprF::Const(Const::Type) };
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 70ce1dc..750b58b 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -1,4 +1,3 @@
-
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::visitor::{self, ExprFMutVisitor, ExprFVisitor};
 use crate::*;
@@ -143,7 +142,7 @@ pub enum Builtin {
 
 // Each node carries an annotation.
 #[derive(Debug, Clone)]
-pub struct Expr<Embed>(Box<(RawExpr<Embed>, Option<Span>)>);
+pub struct Expr<Embed>(Box<(RawExpr<Embed>, Span)>);
 
 pub type RawExpr<Embed> = ExprF<Expr<Embed>, Embed>;
 
@@ -299,16 +298,12 @@ impl<E> Expr<E> {
     pub fn as_mut(&mut self) -> &mut RawExpr<E> {
         &mut self.0.as_mut().0
     }
-    pub fn span(&self) -> Option<Span> {
+    pub fn span(&self) -> Span {
         self.0.as_ref().1.clone()
     }
 
-    pub(crate) fn new(x: RawExpr<E>, n: Span) -> Self {
-        Expr(Box::new((x, Some(n))))
-    }
-
-    pub fn from_expr_no_span(x: RawExpr<E>) -> Self {
-        Expr(Box::new((x, None)))
+    pub fn new(x: RawExpr<E>, n: Span) -> Self {
+        Expr(Box::new((x, n)))
     }
 
     pub fn rewrap<E2>(&self, x: RawExpr<E2>) -> Expr<E2> {
@@ -353,11 +348,6 @@ impl<E> Expr<E> {
     }
 }
 
-// Should probably rename this
-pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
-    Expr::from_expr_no_span(x)
-}
-
 /// Add an isize to an usize
 /// Panics on over/underflow
 fn add_ui(u: usize, i: isize) -> Option<usize> {
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index f0eb89a..fc8de6e 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -14,10 +14,14 @@ pub struct ParsedSpan {
     end: usize,
 }
 
-/// A location in the source text
 #[derive(Debug, Clone)]
 pub enum Span {
+    /// A location in the source text
     Parsed(ParsedSpan),
+    /// For expressions obtained from decoding binary
+    Decoded,
+    /// For expressions constructed during normalization/typecheck
+    Artificial,
 }
 
 impl Span {
@@ -28,17 +32,22 @@ impl Span {
             end: sp.end(),
         })
     }
+
     /// Takes the union of the two spans. Assumes that the spans come from the same input.
     /// This will also capture any input between the spans.
     pub fn union(&self, other: &Span) -> Self {
         use std::cmp::{max, min};
         use Span::*;
         match (self, other) {
-            (Parsed(x), Parsed(y)) => Span::Parsed(ParsedSpan {
+            (Parsed(x), Parsed(y)) => Parsed(ParsedSpan {
                 input: x.input.clone(),
                 start: min(x.start, y.start),
                 end: max(x.end, y.end),
             }),
+            _ => panic!(
+                "Tried to union incompatible spans: {:?} and {:?}",
+                self, other
+            ),
         }
     }
 }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 83f62ee..eaded50 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -650,7 +650,7 @@ impl DhallParser {
                     final_expr,
                     |acc, x| {
                         spanned_union(
-                            acc.span().unwrap(),
+                            acc.span(),
                             x.3,
                             Let(x.0, x.1, x.2, acc)
                         )
@@ -717,11 +717,7 @@ impl DhallParser {
             r => Err(op.error(format!("Rule {:?} isn't an operator", r)))?,
         };
 
-        Ok(spanned_union(
-            l.span().unwrap(),
-            r.span().unwrap(),
-            BinOp(op, l, r),
-        ))
+        Ok(spanned_union(l.span(), r.span(), BinOp(op, l, r)))
     }
 
     fn Some_(_input: ParseInput) -> ParseResult<()> {
@@ -739,8 +735,8 @@ impl DhallParser {
                     first,
                     |acc, e| {
                         spanned_union(
-                            acc.span().unwrap(),
-                            e.span().unwrap(),
+                            acc.span(),
+                            e.span(),
                             App(acc, e)
                         )
                     }
@@ -778,7 +774,7 @@ impl DhallParser {
                     first,
                     |acc, e| {
                         spanned_union(
-                            acc.span().unwrap(),
+                            acc.span(),
                             e.1,
                             match e.0 {
                                 Either::Left(l) => Field(acc, l),
-- 
cgit v1.3.1


From 5d5a356b8eb36e277c312e5550d1cb0a2f82e9fa Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 11:34:29 +0000
Subject: Store a `Span` in `Value`

---
 dhall/src/core/value.rs       | 23 +++++++++++++++++++----
 dhall/src/phase/typecheck.rs  | 14 ++++++++++----
 dhall_syntax/src/core/span.rs |  3 +++
 3 files changed, 32 insertions(+), 8 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs
index b4b6b08..b6c156e 100644
--- a/dhall/src/core/value.rs
+++ b/dhall/src/core/value.rs
@@ -1,7 +1,7 @@
 use std::cell::{Ref, RefCell, RefMut};
 use std::rc::Rc;
 
-use dhall_syntax::{Builtin, Const};
+use dhall_syntax::{Builtin, Const, Span};
 
 use crate::core::context::TypecheckContext;
 use crate::core::valuef::ValueF;
@@ -36,6 +36,7 @@ struct ValueInternal {
     value: ValueF,
     /// This is None if and only if `value` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
+    span: Span,
 }
 
 /// Stores a possibly unevaluated value. Gets (partially) normalized on-demand,
@@ -69,18 +70,21 @@ impl ValueInternal {
                 form: Unevaled,
                 value: ValueF::Const(Const::Type),
                 ty: None,
+                span: Span::Artificial,
             },
             |vint| match (&vint.form, &vint.ty) {
                 (Unevaled, Some(ty)) => ValueInternal {
                     form: WHNF,
                     value: normalize_whnf(vint.value, &ty),
                     ty: vint.ty,
+                    span: vint.span,
                 },
                 // `value` is `Sort`
                 (Unevaled, None) => ValueInternal {
                     form: NF,
                     value: ValueF::Const(Const::Sort),
                     ty: None,
+                    span: vint.span,
                 },
                 // Already in WHNF
                 (WHNF, _) | (NF, _) => vint,
@@ -113,11 +117,12 @@ impl ValueInternal {
 }
 
 impl Value {
-    fn new(value: ValueF, form: Form, ty: Value) -> Value {
+    fn new(value: ValueF, form: Form, ty: Value, span: Span) -> Value {
         ValueInternal {
             form,
             value,
             ty: Some(ty),
+            span,
         }
         .into_value()
     }
@@ -126,14 +131,22 @@ impl Value {
             form: NF,
             value: ValueF::Const(Const::Sort),
             ty: None,
+            span: Span::Artificial,
         }
         .into_value()
     }
     pub(crate) fn from_valuef_and_type(v: ValueF, t: Value) -> Value {
-        Value::new(v, Unevaled, t)
+        Value::new(v, Unevaled, t, Span::PlaceHolder)
+    }
+    pub(crate) fn from_valuef_and_type_and_span(
+        v: ValueF,
+        t: Value,
+        span: Span,
+    ) -> Value {
+        Value::new(v, Unevaled, t, span)
     }
     pub(crate) fn from_valuef_and_type_whnf(v: ValueF, t: Value) -> Value {
-        Value::new(v, WHNF, t)
+        Value::new(v, WHNF, t, Span::PlaceHolder)
     }
     pub(crate) fn from_const(c: Const) -> Self {
         const_to_value(c)
@@ -258,6 +271,7 @@ impl Shift for ValueInternal {
             form: self.form,
             value: self.value.shift(delta, var)?,
             ty: self.ty.shift(delta, var)?,
+            span: self.span.clone(),
         })
     }
 }
@@ -285,6 +299,7 @@ impl Subst<Value> for ValueInternal {
             form: Unevaled,
             value: self.value.subst_shift(var, val),
             ty: self.ty.subst_shift(var, val),
+            span: self.span.clone(),
         }
     }
 }
diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs
index 4d8c7d3..63f5157 100644
--- a/dhall/src/phase/typecheck.rs
+++ b/dhall/src/phase/typecheck.rs
@@ -304,6 +304,7 @@ fn type_with(
     e: Expr<Normalized>,
 ) -> Result<Value, TypeError> {
     use dhall_syntax::ExprF::{Annot, Embed, Lam, Let, Pi, Var};
+    let span = e.span();
 
     Ok(match e.as_ref() {
         Lam(var, annot, body) => {
@@ -348,7 +349,7 @@ fn type_with(
                 |e| type_with(ctx, e.clone()),
                 |_, _| unreachable!(),
             )?;
-            type_last_layer(ctx, expr)?
+            type_last_layer(ctx, expr, span)?
         }
     })
 }
@@ -358,6 +359,7 @@ fn type_with(
 fn type_last_layer(
     ctx: &TypecheckContext,
     e: ExprF<Value, Normalized>,
+    span: Span,
 ) -> Result<Value, TypeError> {
     use crate::error::TypeMessage::*;
     use dhall_syntax::BinOp::*;
@@ -584,6 +586,7 @@ fn type_last_layer(
                 l.get_type()?,
                 r.get_type()?,
             ),
+            Span::PlaceHolder,
         )?),
         BinOp(RecursiveRecordTypeMerge, l, r) => {
             use crate::phase::normalize::merge_maps;
@@ -619,6 +622,7 @@ fn type_last_layer(
                             l.clone(),
                             r.clone(),
                         ),
+                        Span::PlaceHolder,
                     )
                 },
             )?;
@@ -786,9 +790,11 @@ fn type_last_layer(
     };
 
     Ok(match ret {
-        RetTypeOnly(typ) => {
-            Value::from_valuef_and_type(ValueF::PartialExpr(e), typ)
-        }
+        RetTypeOnly(typ) => Value::from_valuef_and_type_and_span(
+            ValueF::PartialExpr(e),
+            typ,
+            span,
+        ),
         RetWhole(v) => v,
     })
 }
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index fc8de6e..fa89c30 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -22,6 +22,9 @@ pub enum Span {
     Decoded,
     /// For expressions constructed during normalization/typecheck
     Artificial,
+    /// For when there should be a span but it's not done yet
+    /// TODO: properly handle spans
+    PlaceHolder,
 }
 
 impl Span {
-- 
cgit v1.3.1


From 330f063e80a51f8f399864f9d01412e1bff34fe9 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 12:43:09 +0000
Subject: Display first pretty type error

---
 dhall/src/error/mod.rs                             |  8 +++----
 dhall/src/phase/typecheck.rs                       |  2 +-
 dhall/src/tests.rs                                 | 25 +++++++++++++++++++++-
 dhall/tests/type-errors/unit/AssertAlphaTrap.txt   |  7 +++++-
 .../unit/UnionDeprecatedConstructorsKeyword.txt    |  7 +++++-
 dhall/tests/type-errors/unit/VariableFree.txt      |  7 +++++-
 dhall_syntax/src/core/span.rs                      | 14 ++++++++++++
 7 files changed, 61 insertions(+), 9 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 5338e2d..efbd578 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,6 +1,6 @@
 use std::io::Error as IOError;
 
-use dhall_syntax::{BinOp, Import, Label, ParseError, V};
+use dhall_syntax::{BinOp, Import, Label, ParseError, Span};
 
 use crate::core::context::TypecheckContext;
 use crate::core::value::Value;
@@ -48,7 +48,7 @@ pub struct TypeError {
 /// The specific type error
 #[derive(Debug)]
 pub(crate) enum TypeMessage {
-    UnboundVariable(V<Label>),
+    UnboundVariable(Span),
     InvalidInputType(Value),
     InvalidOutputType(Value),
     NotAFunction(Value),
@@ -102,8 +102,8 @@ impl TypeError {
 impl std::fmt::Display for TypeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         use TypeMessage::*;
-        let msg = match self.message {
-            UnboundVariable(_) => "Unbound variable".to_string(),
+        let msg = match &self.message {
+            UnboundVariable(span) => span.error("Unbound variable"),
             InvalidInputType(_) => "Invalid function input".to_string(),
             InvalidOutputType(_) => "Invalid function output".to_string(),
             NotAFunction(_) => "Not a function".to_string(),
diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs
index 63f5157..9d2c69b 100644
--- a/dhall/src/phase/typecheck.rs
+++ b/dhall/src/phase/typecheck.rs
@@ -339,7 +339,7 @@ fn type_with(
             None => {
                 return Err(TypeError::new(
                     ctx,
-                    TypeMessage::UnboundVariable(var.clone()),
+                    TypeMessage::UnboundVariable(span),
                 ))
             }
         },
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 9790b95..cde3b03 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -20,6 +20,29 @@ right: `{}`"#,
     }};
 }
 
+/// Wrapper around string slice that makes debug output `{:?}` to print string same way as `{}`.
+/// Used in different `assert*!` macros in combination with `pretty_assertions` crate to make
+/// test failures to show nice diffs.
+#[derive(PartialEq, Eq)]
+#[doc(hidden)]
+pub struct PrettyString(String);
+
+/// Make diff to display string as multi-line string
+impl std::fmt::Debug for PrettyString {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+macro_rules! assert_eq_pretty_str {
+    ($left:expr, $right:expr) => {
+        assert_eq_pretty!(
+            PrettyString($left.to_string()),
+            PrettyString($right.to_string())
+        );
+    };
+}
+
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::PathBuf;
@@ -172,7 +195,7 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             if error_file_path.is_file() {
                 let expected_msg = std::fs::read_to_string(error_file_path)?;
                 let msg = format!("{}\n", err);
-                assert_eq_pretty!(msg, expected_msg);
+                assert_eq_pretty_str!(msg, expected_msg);
             } else {
                 std::fs::create_dir_all(error_file_path.parent().unwrap())?;
                 let mut file = File::create(error_file_path)?;
diff --git a/dhall/tests/type-errors/unit/AssertAlphaTrap.txt b/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
index df2b6c1..f2fc8ce 100644
--- a/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
+++ b/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
@@ -1 +1,6 @@
-Type error: Unbound variable
+Type error:  --> 1:47
+  |
+1 | assert : (\(_: Bool) -> _) === (\(x: Bool) -> _)␊
+  |                                               ^
+  |
+  = Unbound variable
diff --git a/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt b/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
index df2b6c1..f7903de 100644
--- a/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
+++ b/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
@@ -1 +1,6 @@
-Type error: Unbound variable
+Type error:  --> 1:1
+  |
+1 | constructors < Left : Natural | Right : Bool >␊
+  | ^----------^
+  |
+  = Unbound variable
diff --git a/dhall/tests/type-errors/unit/VariableFree.txt b/dhall/tests/type-errors/unit/VariableFree.txt
index df2b6c1..ef1d16e 100644
--- a/dhall/tests/type-errors/unit/VariableFree.txt
+++ b/dhall/tests/type-errors/unit/VariableFree.txt
@@ -1 +1,6 @@
-Type error: Unbound variable
+Type error:  --> 1:1
+  |
+1 | x␊
+  | ^
+  |
+  = Unbound variable
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index fa89c30..e2bf26d 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -53,4 +53,18 @@ impl Span {
             ),
         }
     }
+
+    pub fn error(&self, message: impl Into<String>) -> String {
+        use pest::error::{Error, ErrorVariant};
+        use pest::Span;
+        let message: String = message.into();
+        let span = match self {
+            self::Span::Parsed(span) => span,
+            _ => return format!("Unknown location: {}", message),
+        };
+        let span = Span::new(&*span.input, span.start, span.end).unwrap();
+        let err: ErrorVariant<!> = ErrorVariant::CustomError { message };
+        let err = Error::new_from_span(err, span);
+        format!("{}", err)
+    }
 }
-- 
cgit v1.3.1


From d28d114552e6c6cb913dce48893fa87e87bf11e2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 13:36:30 +0000
Subject: Propagate more spans

---
 dhall/src/core/value.rs       | 8 ++++++--
 dhall/src/phase/typecheck.rs  | 6 +++---
 dhall_syntax/src/core/span.rs | 3 ---
 3 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs
index b6c156e..61c7015 100644
--- a/dhall/src/core/value.rs
+++ b/dhall/src/core/value.rs
@@ -136,7 +136,7 @@ impl Value {
         .into_value()
     }
     pub(crate) fn from_valuef_and_type(v: ValueF, t: Value) -> Value {
-        Value::new(v, Unevaled, t, Span::PlaceHolder)
+        Value::new(v, Unevaled, t, Span::Artificial)
     }
     pub(crate) fn from_valuef_and_type_and_span(
         v: ValueF,
@@ -146,7 +146,7 @@ impl Value {
         Value::new(v, Unevaled, t, span)
     }
     pub(crate) fn from_valuef_and_type_whnf(v: ValueF, t: Value) -> Value {
-        Value::new(v, WHNF, t, Span::PlaceHolder)
+        Value::new(v, WHNF, t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
         const_to_value(c)
@@ -154,6 +154,10 @@ impl Value {
     pub(crate) fn from_builtin(b: Builtin) -> Self {
         builtin_to_value(b)
     }
+    pub(crate) fn with_span(self, span: Span) -> Self {
+        self.as_internal_mut().span = span;
+        self
+    }
 
     pub(crate) fn as_const(&self) -> Option<Const> {
         match &*self.as_whnf() {
diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs
index 9d2c69b..33919e4 100644
--- a/dhall/src/phase/typecheck.rs
+++ b/dhall/src/phase/typecheck.rs
@@ -586,7 +586,7 @@ fn type_last_layer(
                 l.get_type()?,
                 r.get_type()?,
             ),
-            Span::PlaceHolder,
+            Span::Artificial,
         )?),
         BinOp(RecursiveRecordTypeMerge, l, r) => {
             use crate::phase::normalize::merge_maps;
@@ -622,7 +622,7 @@ fn type_last_layer(
                             l.clone(),
                             r.clone(),
                         ),
-                        Span::PlaceHolder,
+                        Span::Artificial,
                     )
                 },
             )?;
@@ -795,7 +795,7 @@ fn type_last_layer(
             typ,
             span,
         ),
-        RetWhole(v) => v,
+        RetWhole(v) => v.with_span(span),
     })
 }
 
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index e2bf26d..d10a53d 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -22,9 +22,6 @@ pub enum Span {
     Decoded,
     /// For expressions constructed during normalization/typecheck
     Artificial,
-    /// For when there should be a span but it's not done yet
-    /// TODO: properly handle spans
-    PlaceHolder,
 }
 
 impl Span {
-- 
cgit v1.3.1


From 207d10c4b7d838d712b135dca56bc31f3fe5b648 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 13:42:31 +0000
Subject: Clarify Span::union and add Span::merge

---
 dhall_syntax/src/core/span.rs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index d10a53d..4012cfb 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -33,8 +33,9 @@ impl Span {
         })
     }
 
-    /// Takes the union of the two spans. Assumes that the spans come from the same input.
-    /// This will also capture any input between the spans.
+    /// Takes the union of the two spans, i.e. the range of input covered by the two spans plus any
+    /// input between them. Assumes that the spans come from the same input. Fails if one of the
+    /// spans does not point to an input location.
     pub fn union(&self, other: &Span) -> Self {
         use std::cmp::{max, min};
         use Span::*;
@@ -51,6 +52,17 @@ impl Span {
         }
     }
 
+    /// Merges two spans assumed to point to a similar thing. If only one of them points to an
+    /// input location, use that one.
+    pub fn merge(&self, other: &Span) -> Self {
+        use Span::*;
+        match (self, other) {
+            (Parsed(x), _) | (_, Parsed(x)) => Parsed(x.clone()),
+            (Artificial, _) | (_, Artificial) => Artificial,
+            (Decoded, Decoded) => Decoded,
+        }
+    }
+
     pub fn error(&self, message: impl Into<String>) -> String {
         use pest::error::{Error, ErrorVariant};
         use pest::Span;
-- 
cgit v1.3.1


From c9c248a4cab21fa1ae7692cd193e3b2c698d431d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 13:49:47 +0000
Subject: Add a few more pretty errors

---
 dhall/src/core/value.rs                                  |  3 +++
 dhall/src/error/mod.rs                                   | 16 ++++++++--------
 dhall/tests/type-errors/hurkensParadox.txt               |  2 +-
 .../unit/FunctionApplicationArgumentNotMatch.txt         |  2 +-
 .../unit/FunctionApplicationIsNotFunction.txt            |  7 ++++++-
 .../type-errors/unit/FunctionArgumentTypeNotAType.txt    |  7 ++++++-
 .../unit/FunctionTypeArgumentTypeNotAType.txt            |  7 ++++++-
 dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt |  7 ++++++-
 dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt |  2 +-
 .../unit/MergeHandlerNotMatchAlternativeType.txt         |  2 +-
 .../tests/type-errors/unit/NaturalSubtractNotNatural.txt |  7 ++++++-
 dhall_syntax/src/core/span.rs                            |  2 +-
 12 files changed, 46 insertions(+), 18 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs
index 61c7015..d4f5131 100644
--- a/dhall/src/core/value.rs
+++ b/dhall/src/core/value.rs
@@ -165,6 +165,9 @@ impl Value {
             _ => None,
         }
     }
+    pub(crate) fn span(&self) -> Span {
+        self.as_internal().span.clone()
+    }
 
     fn as_internal(&self) -> Ref<ValueInternal> {
         self.0.borrow()
diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 02e8ed3..4d59cbb 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -104,16 +104,16 @@ impl std::fmt::Display for TypeError {
         use TypeMessage::*;
         let msg = match &self.message {
             UnboundVariable(span) => span.error("Type error: Unbound variable"),
-            InvalidInputType(_) => {
-                "Type error: Invalid function input".to_string()
+            InvalidInputType(v) => {
+                v.span().error("Type error: Invalid function input")
             }
-            InvalidOutputType(_) => {
-                "Type error: Invalid function output".to_string()
-            }
-            NotAFunction(_) => "Type error: Not a function".to_string(),
-            TypeMismatch(_, _, _) => {
-                "Type error: Wrong type of function argument".to_string()
+            InvalidOutputType(v) => {
+                v.span().error("Type error: Invalid function output")
             }
+            NotAFunction(v) => v.span().error("Type error: Not a function"),
+            TypeMismatch(v, _, _) => v
+                .span()
+                .error("Type error: Wrong type of function argument"),
             _ => "Type error: Unhandled error".to_string(),
         };
         write!(f, "{}", msg)
diff --git a/dhall/tests/type-errors/hurkensParadox.txt b/dhall/tests/type-errors/hurkensParadox.txt
index ab75f15..69428b8 100644
--- a/dhall/tests/type-errors/hurkensParadox.txt
+++ b/dhall/tests/type-errors/hurkensParadox.txt
@@ -1 +1 @@
-Type error: Wrong type of function argument
+[unknown location] Type error: Wrong type of function argument
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
index ab75f15..69428b8 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
@@ -1 +1 @@
-Type error: Wrong type of function argument
+[unknown location] Type error: Wrong type of function argument
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
index 4757d2d..062f9de 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
@@ -1 +1,6 @@
-Type error: Not a function
+ --> 1:1
+  |
+1 | True True␊
+  | ^--^
+  |
+  = Type error: Not a function
diff --git a/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt b/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
index faea460..9e43c33 100644
--- a/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
+++ b/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
@@ -1 +1,6 @@
-Type error: Invalid function input
+ --> 1:7
+  |
+1 | λ(_ : 1) → _␊
+  |       ^
+  |
+  = Type error: Invalid function input
diff --git a/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt b/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
index faea460..dd2e758 100644
--- a/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
+++ b/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
@@ -1 +1,6 @@
-Type error: Invalid function input
+ --> 1:1
+  |
+1 | 2 → _␊
+  | ^
+  |
+  = Type error: Invalid function input
diff --git a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
index ab75f15..bc5cc40 100644
--- a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
@@ -1 +1,6 @@
-Type error: Wrong type of function argument
+ --> 1:6
+  |
+1 | [] : List Type␊
+  |      ^--^
+  |
+  = Type error: Wrong type of function argument
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt b/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
index 4757d2d..c5ed223 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
@@ -1 +1 @@
-Type error: Not a function
+[unknown location] Type error: Not a function
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
index ab75f15..69428b8 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
@@ -1 +1 @@
-Type error: Wrong type of function argument
+[unknown location] Type error: Wrong type of function argument
diff --git a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
index ab75f15..fd906bf 100644
--- a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
+++ b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
@@ -1 +1,6 @@
-Type error: Wrong type of function argument
+ --> 1:1
+  |
+1 | Natural/subtract True True␊
+  | ^--------------^
+  |
+  = Type error: Wrong type of function argument
diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index 4012cfb..d63a619 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -69,7 +69,7 @@ impl Span {
         let message: String = message.into();
         let span = match self {
             self::Span::Parsed(span) => span,
-            _ => return format!("Unknown location: {}", message),
+            _ => return format!("[unknown location] {}", message),
         };
         let span = Span::new(&*span.input, span.start, span.end).unwrap();
         let err: ErrorVariant<!> = ErrorVariant::CustomError { message };
-- 
cgit v1.3.1


From 1c2460bf6ba944d970c6bb6d47863d0244621887 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 11 Nov 2019 13:55:51 +0000
Subject: Ensure spans are compatible in Span::union

---
 dhall_syntax/src/core/span.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/span.rs b/dhall_syntax/src/core/span.rs
index d63a619..f9c7008 100644
--- a/dhall_syntax/src/core/span.rs
+++ b/dhall_syntax/src/core/span.rs
@@ -40,11 +40,13 @@ impl Span {
         use std::cmp::{max, min};
         use Span::*;
         match (self, other) {
-            (Parsed(x), Parsed(y)) => Parsed(ParsedSpan {
-                input: x.input.clone(),
-                start: min(x.start, y.start),
-                end: max(x.end, y.end),
-            }),
+            (Parsed(x), Parsed(y)) if Rc::ptr_eq(&x.input, &y.input) => {
+                Parsed(ParsedSpan {
+                    input: x.input.clone(),
+                    start: min(x.start, y.start),
+                    end: max(x.end, y.end),
+                })
+            }
             _ => panic!(
                 "Tried to union incompatible spans: {:?} and {:?}",
                 self, other
-- 
cgit v1.3.1