From a709c65eb28f1b6a666f15bfc2255da7bc7105ab Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 9 Feb 2020 21:38:37 +0000
Subject: Resolve variables alongside import resolution

---
 dhall/src/error/mod.rs | 56 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 37 insertions(+), 19 deletions(-)

(limited to 'dhall/src/error')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 13b61fa..9cb8a41 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,17 +1,22 @@
 use std::io::Error as IOError;
 
 use crate::semantics::resolve::ImportStack;
+use crate::semantics::Hir;
 use crate::syntax::{Import, ParseError};
-use crate::NormalizedExpr;
 
 mod builder;
 pub(crate) use builder::*;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
+#[derive(Debug)]
+pub struct Error {
+    kind: ErrorKind,
+}
+
 #[derive(Debug)]
 #[non_exhaustive]
-pub enum Error {
+pub(crate) enum ErrorKind {
     IO(IOError),
     Parse(ParseError),
     Decode(DecodeError),
@@ -21,10 +26,9 @@ pub enum Error {
 }
 
 #[derive(Debug)]
-pub enum ImportError {
-    Recursive(Import<NormalizedExpr>, Box<Error>),
-    UnexpectedImport(Import<NormalizedExpr>),
-    ImportCycle(ImportStack, Import<NormalizedExpr>),
+pub(crate) enum ImportError {
+    UnexpectedImport(Import<Hir>),
+    ImportCycle(ImportStack, Import<Hir>),
 }
 
 #[derive(Debug)]
@@ -51,6 +55,15 @@ pub(crate) enum TypeMessage {
     Custom(String),
 }
 
+impl Error {
+    pub(crate) fn new(kind: ErrorKind) -> Self {
+        Error { kind }
+    }
+    pub(crate) fn kind(&self) -> &ErrorKind {
+        &self.kind
+    }
+}
+
 impl TypeError {
     pub(crate) fn new(message: TypeMessage) -> Self {
         TypeError { message }
@@ -72,45 +85,50 @@ impl std::error::Error for TypeError {}
 
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Error::IO(err) => write!(f, "{}", err),
-            Error::Parse(err) => write!(f, "{}", err),
-            Error::Decode(err) => write!(f, "{:?}", err),
-            Error::Encode(err) => write!(f, "{:?}", err),
-            Error::Resolve(err) => write!(f, "{:?}", err),
-            Error::Typecheck(err) => write!(f, "{}", err),
+        match &self.kind {
+            ErrorKind::IO(err) => write!(f, "{}", err),
+            ErrorKind::Parse(err) => write!(f, "{}", err),
+            ErrorKind::Decode(err) => write!(f, "{:?}", err),
+            ErrorKind::Encode(err) => write!(f, "{:?}", err),
+            ErrorKind::Resolve(err) => write!(f, "{:?}", err),
+            ErrorKind::Typecheck(err) => write!(f, "{}", err),
         }
     }
 }
 
 impl std::error::Error for Error {}
+impl From<ErrorKind> for Error {
+    fn from(kind: ErrorKind) -> Error {
+        Error::new(kind)
+    }
+}
 impl From<IOError> for Error {
     fn from(err: IOError) -> Error {
-        Error::IO(err)
+        ErrorKind::IO(err).into()
     }
 }
 impl From<ParseError> for Error {
     fn from(err: ParseError) -> Error {
-        Error::Parse(err)
+        ErrorKind::Parse(err).into()
     }
 }
 impl From<DecodeError> for Error {
     fn from(err: DecodeError) -> Error {
-        Error::Decode(err)
+        ErrorKind::Decode(err).into()
     }
 }
 impl From<EncodeError> for Error {
     fn from(err: EncodeError) -> Error {
-        Error::Encode(err)
+        ErrorKind::Encode(err).into()
     }
 }
 impl From<ImportError> for Error {
     fn from(err: ImportError) -> Error {
-        Error::Resolve(err)
+        ErrorKind::Resolve(err).into()
     }
 }
 impl From<TypeError> for Error {
     fn from(err: TypeError) -> Error {
-        Error::Typecheck(err)
+        ErrorKind::Typecheck(err).into()
     }
 }
-- 
cgit v1.2.3


From 350d1cf7d9c114b1334b2743071b0b99ea64c1ec Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 13 Feb 2020 20:56:38 +0000
Subject: TyExpr always carries a type

---
 dhall/src/error/mod.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'dhall/src/error')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 9cb8a41..51bd549 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -51,7 +51,6 @@ pub struct TypeError {
 /// The specific type error
 #[derive(Debug)]
 pub(crate) enum TypeMessage {
-    Sort,
     Custom(String),
 }
 
@@ -74,7 +73,6 @@ impl std::fmt::Display for TypeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         use TypeMessage::*;
         let msg = match &self.message {
-            Sort => format!("Type error: Unhandled error: {:?}", self.message),
             Custom(s) => format!("Type error: {}", s),
         };
         write!(f, "{}", msg)
-- 
cgit v1.2.3


From a3990858840a737d7831be45953b38bd67361fb7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 18 Feb 2020 19:08:53 +0000
Subject: Discard import headers while we don't use them

---
 dhall/src/error/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'dhall/src/error')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 51bd549..b8f2fca 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -27,8 +27,8 @@ pub(crate) enum ErrorKind {
 
 #[derive(Debug)]
 pub(crate) enum ImportError {
-    UnexpectedImport(Import<Hir>),
-    ImportCycle(ImportStack, Import<Hir>),
+    UnexpectedImport(Import<()>),
+    ImportCycle(ImportStack, Import<()>),
 }
 
 #[derive(Debug)]
-- 
cgit v1.2.3


From 7cbfc1a0d32766a383d1f48902502adaa2234d2f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 18 Feb 2020 19:12:31 +0000
Subject: Avoid re-typechecking after import

---
 dhall/src/error/mod.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'dhall/src/error')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index b8f2fca..8829d47 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,7 +1,6 @@
 use std::io::Error as IOError;
 
 use crate::semantics::resolve::ImportStack;
-use crate::semantics::Hir;
 use crate::syntax::{Import, ParseError};
 
 mod builder;
-- 
cgit v1.2.3