Make most type errors stringy

1 files changed, 48 insertions, 47 deletions

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 850a792..5330c59 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -3,7 +3,7 @@ use std::io::Error as IOError;
 use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
-use crate::syntax::{BinOp, Import, Label, ParseError, Span};
+use crate::syntax::{Import, Label, ParseError, Span};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -48,41 +48,41 @@ pub(crate) enum TypeMessage {
     UnboundVariable(Span),
     InvalidInputType(Value),
     InvalidOutputType(Value),
-    NotAFunction(Value),
-    TypeMismatch(Value, Value, Value),
-    AnnotMismatch(Value, Value),
-    InvalidListElement(usize, Value, Value),
-    InvalidListType(Value),
-    InvalidOptionalType(Value),
-    InvalidPredicate(Value),
-    IfBranchMismatch(Value, Value),
-    IfBranchMustBeTerm(bool, Value),
+    // NotAFunction(Value),
+    // TypeMismatch(Value, Value, Value),
+    // AnnotMismatch(Value, Value),
+    // InvalidListElement(usize, Value, Value),
+    // InvalidListType(Value),
+    // InvalidOptionalType(Value),
+    // InvalidPredicate(Value),
+    // IfBranchMismatch(Value, Value),
+    // IfBranchMustBeTerm(bool, Value),
     InvalidFieldType(Label, Value),
-    NotARecord(Label, Value),
-    MustCombineRecord(Value),
-    MissingRecordField(Label, Value),
-    MissingUnionField(Label, Value),
-    BinOpTypeMismatch(BinOp, Value),
-    InvalidTextInterpolation(Value),
-    Merge1ArgMustBeRecord(Value),
-    Merge2ArgMustBeUnionOrOptional(Value),
-    MergeEmptyNeedsAnnotation,
-    MergeHandlerMissingVariant(Label),
-    MergeVariantMissingHandler(Label),
-    MergeAnnotMismatch,
-    MergeHandlerTypeMismatch,
-    MergeHandlerReturnTypeMustNotBeDependent,
-    ProjectionMustBeRecord,
-    ProjectionMissingEntry,
-    ProjectionDuplicateField,
+    // NotARecord(Label, Value),
+    // MustCombineRecord(Value),
+    // MissingRecordField(Label, Value),
+    // MissingUnionField(Label, Value),
+    // BinOpTypeMismatch(BinOp, Value),
+    // InvalidTextInterpolation(Value),
+    // Merge1ArgMustBeRecord(Value),
+    // Merge2ArgMustBeUnionOrOptional(Value),
+    // MergeEmptyNeedsAnnotation,
+    // MergeHandlerMissingVariant(Label),
+    // MergeVariantMissingHandler(Label),
+    // MergeAnnotMismatch,
+    // MergeHandlerTypeMismatch,
+    // MergeHandlerReturnTypeMustNotBeDependent,
+    // ProjectionMustBeRecord,
+    // ProjectionMissingEntry,
+    // ProjectionDuplicateField,
     Sort,
     RecordTypeDuplicateField,
-    RecordTypeMergeRequiresRecordType(Value),
+    // RecordTypeMergeRequiresRecordType(Value),
     UnionTypeDuplicateField,
-    EquivalenceArgumentMustBeTerm(bool, Value),
-    EquivalenceTypeMismatch(Value, Value),
-    AssertMismatch(Value, Value),
-    AssertMustTakeEquivalence,
+    // EquivalenceArgumentMustBeTerm(bool, Value),
+    // EquivalenceTypeMismatch(Value, Value),
+    // AssertMismatch(Value, Value),
+    // AssertMustTakeEquivalence,
     Custom(String),
 }
 
@@ -103,21 +103,22 @@ impl std::fmt::Display for TypeError {
             InvalidOutputType(v) => {
                 v.span().error("Type error: Invalid function output")
             }
-            NotAFunction(v) => v.span().error("Type error: Not a function"),
-            TypeMismatch(x, y, z) => {
-                x.span()
-                    .error("Type error: Wrong type of function argument")
-                    + "\n"
-                    + &z.span().error(format!(
-                        "This argument has type {:?}",
-                        z.get_type().unwrap()
-                    ))
-                    + "\n"
-                    + &y.span().error(format!(
-                        "But the function expected an argument of type {:?}",
-                        y
-                    ))
-            }
+            // NotAFunction(v) => v.span().error("Type error: Not a function"),
+            // TypeMismatch(x, y, z) => {
+            //     x.span()
+            //         .error("Type error: Wrong type of function argument")
+            //         + "\n"
+            //         + &z.span().error(format!(
+            //             "This argument has type {:?}",
+            //             z.get_type().unwrap()
+            //         ))
+            //         + "\n"
+            //         + &y.span().error(format!(
+            //             "But the function expected an argument of type {:?}",
+            //             y
+            //         ))
+            // }
+            Custom(s) => format!("Type error: Unhandled error: {}", s),
             _ => format!("Type error: Unhandled error: {:?}", self.message),
         };
         write!(f, "{}", msg)