From f1b12a26e5b7a1fae24bad1b918c8cb4c94dfe49 Mon Sep 17 00:00:00 2001
From: nisstyre56 <wjak56@gmail.com>
Date: Fri, 16 May 2014 20:43:58 -0400
Subject: [PATCH] Better error messages for type application errors where
 something that was not a type operator, type variable, or type application is
 used

---
 desugar.js        | 11 +++++++++--
 errors.js         |  3 +--
 example.jl        |  2 +-
 parse.js          |  3 ++-
 representation.js | 35 ++++++++++++++++++++++++++++-------
 5 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/desugar.js b/desugar.js
index 020cc7f..d0a2aa0 100644
--- a/desugar.js
+++ b/desugar.js
@@ -57,6 +57,8 @@ function sugarTypeApp(stx) {
 
 
 function desugar(stx) {
+ var typeExpTest;
+
  switch (stx.exprType) {
     case "If":
       if (stx.elseexp) {
@@ -76,8 +78,13 @@ function desugar(stx) {
              * In this case we actually *add* syntax here to differentiate type applications
              * from normal applications
              */
-            if (!typ.isTypeExpr(stx.p)) {
-              throw errors.JInternalError("Type application error near line " + stx.linenum + " at character #"+stx.charnum);
+            typeExpTest = typ.isTypeExpr(stx.p);
+
+            if (typeExpTest.failed !== undefined &&
+                typeExpTest.failed) {
+              throw errors.JInternalError(
+                "Type application error near line " + stx.linenum + " at character #"+stx.charnum +
+                "\n"+typeExpTest.stx.exprType+" (" + typeExpTest.stx.val + ") found where a type operator or type application was expected");
             }
             return sugarTypeApp(stx);
           }
diff --git a/errors.js b/errors.js
index 0eebc6a..466d800 100644
--- a/errors.js
+++ b/errors.js
@@ -10,7 +10,7 @@ function JSyntaxError(linenum, charnum, message) {
   this.charnum = charnum;
   this.errormessage = message;
   this.stxerror = function() {
-  console.log("Syntax Error\n",
+    console.log("Syntax Error\n",
                 "Line #", this.linenum-2,"\n",
                 "Near character #", this.charnum, "\n",
                 this.errormessage);
@@ -28,7 +28,6 @@ function JTypeError(linenum, charnum, token, message) {
 
 function JInternalError(message) {
   this.errormessage = message;
-  console.log(message);
   return this;
 }
 
diff --git a/example.jl b/example.jl
index 3f2c11b..3ed8bd3 100644
--- a/example.jl
+++ b/example.jl
@@ -1,7 +1,7 @@
 defop 2 Left (a ++ b)
  (a - b)
 
-(qat :: (T -> 2))
+(qat :: (T -> B -> "wat"))
 def qat (lambda a b c -> (a + b))
 
 def (add a b)
diff --git a/parse.js b/parse.js
index 139a77f..886507b 100755
--- a/parse.js
+++ b/parse.js
@@ -701,11 +701,12 @@ function parseFull(tokenized) {
   } catch (e) {
       if (e.stxerror !== undefined) {
         e.stxerror();
+        process.exit(1);
       }
       else {
         console.log(e.errormessage);
+        process.exit(1);
       }
-      process.exit(1);
   }
 }
 
diff --git a/representation.js b/representation.js
index c03af68..64f298b 100644
--- a/representation.js
+++ b/representation.js
@@ -35,27 +35,48 @@ function isIrregularTypeOp(x) {
   return (x === "->");
 }
 
-function isTypeExprRec(stx, isTypeOp) {
+function flattenTypeApp(stx) {
   if (isTypeExpr(stx)) {
-    return true;
+    return stx;
   }
   if (stx.exprType === "Application") {
     /* it might be a type application so recursively check it */
     if (stx.p !== undefined) {
-      return (isTypeExprRec(stx.p) &&
-              isTypeExprRec(stx.func));
+      return  _.flatten([stx, flattenTypeApp(stx.p), flattenTypeApp(stx.func)]);
     }
     else {
-      return isTypeExprRec(stx.func);
+      return _.flatten([stx, flattenTypeApp(stx.func)]);
     }
   }
   if (stx.exprType === "Name") {
     /* Check if it might be a type operator that is not capitalized */
-    return isIrregularTypeOp(stx.ident);
+    if (isIrregularTypeOp(stx.ident)) {
+      return stx;
+    }
+    return {
+      failed : true,
+      stx : stx
+    };
   }
-  return false;
+  return {
+    failed : true,
+    stx : stx
+  };
 }
 
+function isTypeExprRec(stx) {
+  var flattened = flattenTypeApp(stx);
+  for(var i = 0; i < flattened.length; i++) {
+    if (flattened[i].failed !== undefined &&
+        flattened[i].failed) {
+          return flattened[i];
+        }
+  }
+  return true;
+}
+
+
+
 function App(func, p) {
   this.func = func;
   this.exprType = "Application";