Move main API to lib.rs

13 files changed, 256 insertions, 254 deletions

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 852e795..8991758 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,9 +1,9 @@
 use std::io::Error as IOError;
 
 use crate::semantics::phase::resolve::ImportStack;
-use crate::semantics::phase::NormalizedExpr;
 use crate::semantics::Value;
 use crate::syntax::{Import, ParseError};
+use crate::NormalizedExpr;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 62a1b27..cbf3ceb 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -16,3 +16,247 @@ mod tests;
 pub mod error;
 pub mod semantics;
 pub mod syntax;
+
+use std::fmt::Display;
+use std::path::Path;
+
+use crate::error::{EncodeError, Error, ImportError, TypeError};
+use crate::semantics::phase::parse;
+use crate::semantics::phase::resolve;
+use crate::semantics::phase::resolve::ImportRoot;
+use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
+use crate::syntax::binary;
+use crate::syntax::{Builtin, Const, Expr};
+
+pub type ParsedExpr = Expr<Normalized>;
+pub type DecodedExpr = Expr<Normalized>;
+pub type ResolvedExpr = Expr<Normalized>;
+pub type NormalizedExpr = Expr<Normalized>;
+
+#[derive(Debug, Clone)]
+pub struct Parsed(ParsedExpr, ImportRoot);
+
+/// An expression where all imports have been resolved
+///
+/// Invariant: there must be no `Import` nodes or `ImportAlt` operations left.
+#[derive(Debug, Clone)]
+pub struct Resolved(ResolvedExpr);
+
+/// A typed expression
+#[derive(Debug, Clone)]
+pub struct Typed(TyExpr);
+
+/// A normalized expression.
+///
+/// Invariant: the contained Typed expression must be in normal form,
+#[derive(Debug, Clone)]
+pub struct Normalized(Value);
+
+/// Controls conversion from `Value` to `Expr`
+#[derive(Copy, Clone)]
+pub(crate) struct ToExprOptions {
+    /// Whether to convert all variables to `_`
+    pub(crate) alpha: bool,
+    /// Whether to normalize before converting
+    pub(crate) normalize: bool,
+}
+
+impl Parsed {
+    pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
+        parse::parse_file(f)
+    }
+    pub fn parse_str(s: &str) -> Result<Parsed, Error> {
+        parse::parse_str(s)
+    }
+    pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
+        parse::parse_binary_file(f)
+    }
+    pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
+        parse::parse_binary(data)
+    }
+
+    pub fn resolve(self) -> Result<Resolved, ImportError> {
+        resolve::resolve(self)
+    }
+    pub fn skip_resolve(self) -> Result<Resolved, ImportError> {
+        resolve::skip_resolve_expr(self)
+    }
+
+    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
+        binary::encode(&self.0)
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> ParsedExpr {
+        self.0.clone()
+    }
+}
+
+impl Resolved {
+    pub fn typecheck(&self) -> Result<Typed, TypeError> {
+        Ok(Typed(typecheck(&self.0)?))
+    }
+    pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
+        Ok(Typed(typecheck_with(&self.0, ty.to_expr())?))
+    }
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> ResolvedExpr {
+        self.0.clone()
+    }
+}
+
+impl Typed {
+    /// Reduce an expression to its normal form, performing beta reduction
+    pub fn normalize(&self) -> Normalized {
+        Normalized(self.0.rec_eval_closed_expr())
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    fn to_expr(&self) -> ResolvedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
+    }
+
+    pub(crate) fn get_type(&self) -> Result<Normalized, TypeError> {
+        Ok(Normalized(self.0.get_type()?))
+    }
+}
+
+impl Normalized {
+    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
+        binary::encode(&self.to_expr())
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> NormalizedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
+    }
+    /// Converts a value back to the corresponding AST expression, alpha-normalizing in the process.
+    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: true,
+            normalize: false,
+        })
+    }
+    pub(crate) fn to_value(&self) -> Value {
+        self.0.clone()
+    }
+    pub(crate) fn into_value(self) -> Value {
+        self.0
+    }
+
+    pub(crate) fn from_const(c: Const) -> Self {
+        Normalized(Value::from_const(c))
+    }
+    pub(crate) fn from_kind_and_type(
+        v: ValueKind<Value>,
+        t: Normalized,
+    ) -> Self {
+        Normalized(Value::from_kind_and_type(v, t.into_value()))
+    }
+    pub(crate) fn from_value(th: Value) -> Self {
+        Normalized(th)
+    }
+    pub(crate) fn const_type() -> Self {
+        Normalized::from_const(Const::Type)
+    }
+
+    pub fn make_builtin_type(b: Builtin) -> Self {
+        Normalized::from_value(Value::from_builtin(b))
+    }
+    pub fn make_optional_type(t: Normalized) -> Self {
+        Normalized::from_value(
+            Value::from_builtin(Builtin::Optional).app(t.to_value()),
+        )
+    }
+    pub fn make_list_type(t: Normalized) -> Self {
+        Normalized::from_value(
+            Value::from_builtin(Builtin::List).app(t.to_value()),
+        )
+    }
+    pub fn make_record_type(
+        kts: impl Iterator<Item = (String, Normalized)>,
+    ) -> Self {
+        Normalized::from_kind_and_type(
+            ValueKind::RecordType(
+                kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
+            ),
+            Normalized::const_type(),
+        )
+    }
+    pub fn make_union_type(
+        kts: impl Iterator<Item = (String, Option<Normalized>)>,
+    ) -> Self {
+        Normalized::from_kind_and_type(
+            ValueKind::UnionType(
+                kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
+                    .collect(),
+            ),
+            Normalized::const_type(),
+        )
+    }
+}
+
+macro_rules! derive_traits_for_wrapper_struct {
+    ($ty:ident) => {
+        impl std::cmp::PartialEq for $ty {
+            fn eq(&self, other: &Self) -> bool {
+                self.0 == other.0
+            }
+        }
+
+        impl std::cmp::Eq for $ty {}
+
+        impl std::fmt::Display for $ty {
+            fn fmt(
+                &self,
+                f: &mut std::fmt::Formatter,
+            ) -> Result<(), std::fmt::Error> {
+                self.0.fmt(f)
+            }
+        }
+    };
+}
+
+derive_traits_for_wrapper_struct!(Parsed);
+derive_traits_for_wrapper_struct!(Resolved);
+
+impl std::hash::Hash for Normalized {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        if let Ok(vec) = self.encode() {
+            vec.hash(state)
+        }
+    }
+}
+
+impl Eq for Typed {}
+impl PartialEq for Typed {
+    fn eq(&self, other: &Self) -> bool {
+        self.normalize() == other.normalize()
+    }
+}
+impl Display for Typed {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.to_expr().fmt(f)
+    }
+}
+
+impl Eq for Normalized {}
+impl PartialEq for Normalized {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+impl Display for Normalized {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.to_expr().fmt(f)
+    }
+}
diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 9d10d89..2211579 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -1,4 +1,3 @@
-use crate::semantics::phase::Normalized;
 use crate::semantics::{
     typecheck, NzEnv, TyExpr, TyExprKind, Value, ValueKind, VarEnv,
 };
@@ -8,6 +7,7 @@ use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedText,
     InterpolatedTextContents, Label, NaiveDouble, Span, UnspannedExpr, V,
 };
+use crate::Normalized;
 use std::collections::HashMap;
 use std::convert::TryInto;
 
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index ea1a25b..6564018 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use crate::semantics::phase::Normalized;
 use crate::semantics::NzEnv;
 use crate::semantics::{
     Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
@@ -8,6 +7,7 @@ use crate::semantics::{
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
 };
+use crate::Normalized;
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.kind();
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 215c342..0a9de6a 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -4,7 +4,6 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::nze::visitor;
-use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
 use crate::semantics::Binder;
 use crate::semantics::{apply_any, normalize_tyexpr_whnf, normalize_whnf};
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
@@ -13,6 +12,7 @@ use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
 };
+use crate::{Normalized, NormalizedExpr, ToExprOptions};
 
 use self::Form::{Unevaled, WHNF};
 
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index ff4b859..02e2b18 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -1,244 +1,2 @@
-use std::fmt::Display;
-use std::path::Path;
-
-use crate::error::{EncodeError, Error, ImportError, TypeError};
-use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
-use crate::syntax::binary;
-use crate::syntax::{Builtin, Const, Expr};
-use resolve::ImportRoot;
-
 pub(crate) mod parse;
 pub(crate) mod resolve;
-
-pub type ParsedExpr = Expr<Normalized>;
-pub type DecodedExpr = Expr<Normalized>;
-pub type ResolvedExpr = Expr<Normalized>;
-pub type NormalizedExpr = Expr<Normalized>;
-
-#[derive(Debug, Clone)]
-pub struct Parsed(ParsedExpr, ImportRoot);
-
-/// An expression where all imports have been resolved
-///
-/// Invariant: there must be no `Import` nodes or `ImportAlt` operations left.
-#[derive(Debug, Clone)]
-pub struct Resolved(ResolvedExpr);
-
-/// A typed expression
-#[derive(Debug, Clone)]
-pub struct Typed(TyExpr);
-
-/// A normalized expression.
-///
-/// Invariant: the contained Typed expression must be in normal form,
-#[derive(Debug, Clone)]
-pub struct Normalized(Value);
-
-/// Controls conversion from `Value` to `Expr`
-#[derive(Copy, Clone)]
-pub(crate) struct ToExprOptions {
-    /// Whether to convert all variables to `_`
-    pub(crate) alpha: bool,
-    /// Whether to normalize before converting
-    pub(crate) normalize: bool,
-}
-
-impl Parsed {
-    pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
-        parse::parse_file(f)
-    }
-    pub fn parse_str(s: &str) -> Result<Parsed, Error> {
-        parse::parse_str(s)
-    }
-    pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
-        parse::parse_binary_file(f)
-    }
-    pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
-        parse::parse_binary(data)
-    }
-
-    pub fn resolve(self) -> Result<Resolved, ImportError> {
-        resolve::resolve(self)
-    }
-    pub fn skip_resolve(self) -> Result<Resolved, ImportError> {
-        resolve::skip_resolve_expr(self)
-    }
-
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.0)
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> ParsedExpr {
-        self.0.clone()
-    }
-}
-
-impl Resolved {
-    pub fn typecheck(&self) -> Result<Typed, TypeError> {
-        Ok(Typed(typecheck(&self.0)?))
-    }
-    pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
-        Ok(Typed(typecheck_with(&self.0, ty.to_expr())?))
-    }
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> ResolvedExpr {
-        self.0.clone()
-    }
-}
-
-impl Typed {
-    /// Reduce an expression to its normal form, performing beta reduction
-    pub fn normalize(&self) -> Normalized {
-        Normalized(self.0.rec_eval_closed_expr())
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    fn to_expr(&self) -> ResolvedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: false,
-            normalize: false,
-        })
-    }
-
-    pub(crate) fn get_type(&self) -> Result<Normalized, TypeError> {
-        Ok(Normalized(self.0.get_type()?))
-    }
-}
-
-impl Normalized {
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.to_expr())
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: false,
-            normalize: false,
-        })
-    }
-    /// Converts a value back to the corresponding AST expression, alpha-normalizing in the process.
-    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: true,
-            normalize: false,
-        })
-    }
-    pub(crate) fn to_value(&self) -> Value {
-        self.0.clone()
-    }
-    pub(crate) fn into_value(self) -> Value {
-        self.0
-    }
-
-    pub(crate) fn from_const(c: Const) -> Self {
-        Normalized(Value::from_const(c))
-    }
-    pub(crate) fn from_kind_and_type(
-        v: ValueKind<Value>,
-        t: Normalized,
-    ) -> Self {
-        Normalized(Value::from_kind_and_type(v, t.into_value()))
-    }
-    pub(crate) fn from_value(th: Value) -> Self {
-        Normalized(th)
-    }
-    pub(crate) fn const_type() -> Self {
-        Normalized::from_const(Const::Type)
-    }
-
-    pub fn make_builtin_type(b: Builtin) -> Self {
-        Normalized::from_value(Value::from_builtin(b))
-    }
-    pub fn make_optional_type(t: Normalized) -> Self {
-        Normalized::from_value(
-            Value::from_builtin(Builtin::Optional).app(t.to_value()),
-        )
-    }
-    pub fn make_list_type(t: Normalized) -> Self {
-        Normalized::from_value(
-            Value::from_builtin(Builtin::List).app(t.to_value()),
-        )
-    }
-    pub fn make_record_type(
-        kts: impl Iterator<Item = (String, Normalized)>,
-    ) -> Self {
-        Normalized::from_kind_and_type(
-            ValueKind::RecordType(
-                kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
-            ),
-            Normalized::const_type(),
-        )
-    }
-    pub fn make_union_type(
-        kts: impl Iterator<Item = (String, Option<Normalized>)>,
-    ) -> Self {
-        Normalized::from_kind_and_type(
-            ValueKind::UnionType(
-                kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
-                    .collect(),
-            ),
-            Normalized::const_type(),
-        )
-    }
-}
-
-macro_rules! derive_traits_for_wrapper_struct {
-    ($ty:ident) => {
-        impl std::cmp::PartialEq for $ty {
-            fn eq(&self, other: &Self) -> bool {
-                self.0 == other.0
-            }
-        }
-
-        impl std::cmp::Eq for $ty {}
-
-        impl std::fmt::Display for $ty {
-            fn fmt(
-                &self,
-                f: &mut std::fmt::Formatter,
-            ) -> Result<(), std::fmt::Error> {
-                self.0.fmt(f)
-            }
-        }
-    };
-}
-
-derive_traits_for_wrapper_struct!(Parsed);
-derive_traits_for_wrapper_struct!(Resolved);
-
-impl std::hash::Hash for Normalized {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: std::hash::Hasher,
-    {
-        if let Ok(vec) = self.encode() {
-            vec.hash(state)
-        }
-    }
-}
-
-impl Eq for Typed {}
-impl PartialEq for Typed {
-    fn eq(&self, other: &Self) -> bool {
-        self.normalize() == other.normalize()
-    }
-}
-impl Display for Typed {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        self.to_expr().fmt(f)
-    }
-}
-
-impl Eq for Normalized {}
-impl PartialEq for Normalized {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-impl Display for Normalized {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        self.to_expr().fmt(f)
-    }
-}
diff --git a/dhall/src/semantics/phase/parse.rs b/dhall/src/semantics/phase/parse.rs
index 00db422..b72fe7f 100644
--- a/dhall/src/semantics/phase/parse.rs
+++ b/dhall/src/semantics/phase/parse.rs
@@ -4,9 +4,9 @@ use std::path::Path;
 
 use crate::error::Error;
 use crate::semantics::phase::resolve::ImportRoot;
-use crate::semantics::phase::Parsed;
 use crate::syntax::binary;
 use crate::syntax::parse_expr;
+use crate::Parsed;
 
 pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> {
     let mut buffer = String::new();
diff --git a/dhall/src/semantics/phase/resolve.rs b/dhall/src/semantics/phase/resolve.rs
index cc4a024..3acf114 100644
--- a/dhall/src/semantics/phase/resolve.rs
+++ b/dhall/src/semantics/phase/resolve.rs
@@ -2,9 +2,9 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use crate::error::{Error, ImportError};
-use crate::semantics::phase::{Normalized, NormalizedExpr, Parsed, Resolved};
 use crate::syntax;
 use crate::syntax::{FilePath, ImportLocation, URL};
+use crate::{Normalized, NormalizedExpr, Parsed, Resolved};
 
 type Import = syntax::Import<NormalizedExpr>;
 
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 98dc3f9..4b88048 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,9 +1,9 @@
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::normalize_tyexpr_whnf;
-use crate::semantics::phase::Normalized;
-use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
 use crate::semantics::{rc, NameEnv, NzEnv, TyEnv, Value};
 use crate::syntax::{ExprKind, Span, V};
+use crate::Normalized;
+use crate::{NormalizedExpr, ToExprOptions};
 
 pub(crate) type Type = Value;
 
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 348471f..212e6e7 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -4,7 +4,6 @@ use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::merge_maps;
-use crate::semantics::phase::Normalized;
 use crate::semantics::{
     type_of_builtin, Binder, BuiltinClosure, Closure, TyEnv, TyExpr,
     TyExprKind, Type, Value, ValueKind,
@@ -12,6 +11,7 @@ use crate::semantics::{
 use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Span,
 };
+use crate::Normalized;
 
 fn type_of_recordtype<'a>(
     tys: impl Iterator<Item = Cow<'a, TyExpr>>,
diff --git a/dhall/src/syntax/binary/decode.rs b/dhall/src/syntax/binary/decode.rs
index c18deb5..52b699c 100644
--- a/dhall/src/syntax/binary/decode.rs
+++ b/dhall/src/syntax/binary/decode.rs
@@ -3,13 +3,13 @@ use serde_cbor::value::value as cbor;
 use std::iter::FromIterator;
 
 use crate::error::DecodeError;
-use crate::semantics::phase::DecodedExpr;
 use crate::syntax;
 use crate::syntax::{
     Expr, ExprKind, FilePath, FilePrefix, Hash, ImportLocation, ImportMode,
     Integer, InterpolatedText, Label, Natural, Scheme, Span, UnspannedExpr,
     URL, V,
 };
+use crate::DecodedExpr;
 
 pub(crate) fn decode(data: &[u8]) -> Result<DecodedExpr, DecodeError> {
     match serde_cbor::de::from_slice(data) {
diff --git a/dhall/src/syntax/text/parser.rs b/dhall/src/syntax/text/parser.rs
index 681d6dd..2ec63e2 100644
--- a/dhall/src/syntax/text/parser.rs
+++ b/dhall/src/syntax/text/parser.rs
@@ -5,7 +5,6 @@ use std::rc::Rc;
 
 use pest_consume::{match_nodes, Parser};
 
-use crate::semantics::phase::Normalized;
 use crate::syntax;
 use crate::syntax::map::{DupTreeMap, DupTreeSet};
 use crate::syntax::ExprKind::*;
@@ -14,6 +13,7 @@ use crate::syntax::{
     InterpolatedText, InterpolatedTextContents, Label, NaiveDouble, Natural,
     Scheme, Span, UnspannedExpr, URL, V,
 };
+use crate::Normalized;
 
 // This file consumes the parse tree generated by pest and turns it into
 // our own AST. All those custom macros should eventually moved into
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 08feadf..8216243 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -48,7 +48,7 @@ use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use crate::error::{Error, Result};
-use crate::semantics::phase::Parsed;
+use crate::Parsed;
 
 #[allow(dead_code)]
 #[derive(Clone)]