Typed and TypedHir are the same

1 files changed, 12 insertions, 18 deletions

diff --git a/dhall/src/semantics/resolve/resolve.rs b/dhall/src/semantics/resolve/resolve.rs
index d6bc4cd..002490b 100644
--- a/dhall/src/semantics/resolve/resolve.rs
+++ b/dhall/src/semantics/resolve/resolve.rs
@@ -16,14 +16,11 @@ use crate::syntax::{
     Expr, ExprKind, FilePath, FilePrefix, Hash, ImportMode, ImportTarget,
     Label, Span, UnspannedExpr, URL,
 };
-use crate::{Parsed, Resolved};
+use crate::{Parsed, Resolved, Typed};
 
 // TODO: evaluate import headers
 pub type Import = syntax::Import<()>;
 
-/// Owned Hir with a type. Different from Tir because the Hir is owned.
-pub type TypedHir = (Hir, Type);
-
 /// The location of some data, usually some dhall code.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ImportLocation {
@@ -220,14 +217,10 @@ fn make_aslocation_uniontype() -> Expr {
     mkexpr(ExprKind::UnionType(union))
 }
 
-fn check_hash(
-    import: &Import,
-    typed: &TypedHir,
-    span: Span,
-) -> Result<(), Error> {
+fn check_hash(import: &Import, typed: &Typed, span: Span) -> Result<(), Error> {
     match (import.mode, &import.hash) {
         (ImportMode::Code, Some(Hash::SHA256(hash))) => {
-            let actual_hash = typed.0.to_expr_alpha().sha256_hash()?;
+            let actual_hash = typed.hir.to_expr_alpha().sha256_hash()?;
             if hash[..] != actual_hash[..] {
                 mkerr(
                     ErrorBuilder::new("hash mismatch")
@@ -251,27 +244,28 @@ fn resolve_one_import(
     import: &Import,
     location: ImportLocation,
     span: Span,
-) -> Result<TypedHir, Error> {
-    match import.mode {
+) -> Result<Typed, Error> {
+    let (hir, ty) = match import.mode {
         ImportMode::Code => {
             let parsed = location.fetch_dhall()?;
             let typed = resolve_with_env(env, parsed)?.typecheck()?;
             let hir = typed.normalize().to_hir();
-            Ok((hir, typed.ty))
+            (hir, typed.ty)
         }
         ImportMode::RawText => {
             let text = location.fetch_text()?;
             let hir =
                 Hir::new(HirKind::Expr(ExprKind::TextLit(text.into())), span);
-            Ok((hir, Type::from_builtin(Builtin::Text)))
+            (hir, Type::from_builtin(Builtin::Text))
         }
         ImportMode::Location => {
             let expr = location.into_location();
             let hir = skip_resolve_expr(&expr)?;
             let ty = hir.typecheck_noenv()?.ty().clone();
-            Ok((hir, ty))
+            (hir, ty)
         }
-    }
+    };
+    Ok(Typed { hir, ty })
 }
 
 /// Desugar a `with` expression.
@@ -335,7 +329,7 @@ fn desugar(expr: &Expr) -> Cow<'_, Expr> {
 fn traverse_resolve_expr(
     name_env: &mut NameEnv,
     expr: &Expr,
-    f: &mut impl FnMut(Import, Span) -> Result<TypedHir, Error>,
+    f: &mut impl FnMut(Import, Span) -> Result<Typed, Error>,
 ) -> Result<Hir, Error> {
     let expr = desugar(expr);
     Ok(match expr.kind() {
@@ -375,7 +369,7 @@ fn traverse_resolve_expr(
                     // TODO: evaluate import headers
                     let import = import.traverse_ref(|_| Ok::<_, Error>(()))?;
                     let imported = f(import, expr.span())?;
-                    HirKind::Import(imported.0, imported.1)
+                    HirKind::Import(imported.hir, imported.ty)
                 }
                 kind => HirKind::Expr(kind),
             };