the Error type; better lexer error reporting

src/GF/Compile/CheckGrammar.hs

@@ -288,6 +288,7 @@ computeLType gr t = do
     App (Q (IC "Predef") (IC "Ints")) _ -> return ty ---- shouldn't be needed
     Q (IC "Predef") (IC "Int")          -> return ty ---- shouldn't be needed
     Q (IC "Predef") (IC "Float")        -> return ty ---- shouldn't be needed
+    Q (IC "Predef") (IC "Error")        -> return ty ---- shouldn't be needed
 
     Q m c | elem c [cPredef,cPredefAbs] -> return ty
     Q m c | elem c [zIdent "Int"] -> 
@@ -777,13 +778,16 @@ checkEqLType env t u trm = do
         checkWarn $ "WARNING: missing lock field" +++ unwords (map prt lo)
         return t'
       Bad s -> raise (s +++ "type of" +++ prt trm +++ 
-                ": expected" ++++ prt t' ++++ "inferred" ++++ prt u')
+                ": expected" ++++ prt t' ++++ "inferred" ++++ prt u' ++++ show u')
  where
 
    -- t is a subtype of u 
    --- quick hack version of TC.eqVal
    alpha g t u = case (t,u) of  
 
+     -- error (the empty type!) is subtype of any other type
+     (_,Q (IC "Predef") (IC "Error")) -> True
+
      -- contravariance
      (Prod x a b, Prod y c d) -> alpha g c a && alpha ((x,y):g) b d 
                               

src/GF/Compile/GrammarToCanon.hs

@@ -194,11 +194,12 @@ redCTerm t = case t of
   Vr x -> checkAgain 
             (liftM G.Arg $ redArgvar x) 
             (liftM G.LI  $ redIdent x) --- for parametrize optimization
-  App _ _ -> do  -- only constructor applications can remain
+  App _ s -> do  -- only constructor applications can remain
     (_,c,xx) <- termForm t
     xx' <- mapM redCTerm xx
     case c of
       QC p c -> liftM2 G.Par (redQIdent (p,c)) (return xx')
+      Q (IC "Predef") (IC "error") -> fail $ "error: " ++ stringFromTerm s
       _ -> prtBad "expected constructor head instead of" c
   Q p c  -> liftM G.I (redQIdent (p,c))
   QC p c -> liftM2 G.Par (redQIdent (p,c)) (return [])

src/GF/Grammar/AppPredefined.hs

@@ -31,8 +31,10 @@ typPredefined :: Ident -> Err Type
 typPredefined c@(IC f) = case f of
   "Int"    -> return typePType
   "Float"  -> return typePType
+  "Error"  -> return typeType
   "Ints"   -> return $ mkFunType [cnPredef "Int"] typePType
   "PBool"  -> return typePType
+  "error"  -> return $ mkFunType [typeStr] (cnPredef "Error")  -- non-can. of empty set
   "PFalse" -> return $ cnPredef "PBool"
   "PTrue"  -> return $ cnPredef "PBool"
   "dp"     -> return $ mkFunType [cnPredef "Int",typeTok] typeTok

src/GF/Shell/HelpFile.hs

@@ -614,7 +614,9 @@ txtHelpFile =
   "\n       The default is share for concrete, none for resource modules." ++
   "\n       Each of the flags can have the suffix _subs, which performs" ++
   "\n       common subexpression elimination after the main optimization." ++
-  "\n       Thus, -optimize=all_subs is the most aggressive one." ++
+  "\n       Thus, -optimize=all_subs is the most aggressive one. The _subs" ++
+  "\n       strategy only works in GFC, and applies therefore in concrete but" ++
+  "\n       not in resource modules." ++
   "\n    -optimize=share        share common branches in tables" ++
   "\n    -optimize=parametrize  first try parametrize then do share with the rest" ++
   "\n    -optimize=values       represent tables as courses-of-values" ++

src/HelpFile

@@ -585,7 +585,9 @@ q, quit: q
        The default is share for concrete, none for resource modules.
        Each of the flags can have the suffix _subs, which performs
        common subexpression elimination after the main optimization.
-       Thus, -optimize=all_subs is the most aggressive one.
+       Thus, -optimize=all_subs is the most aggressive one. The _subs
+       strategy only works in GFC, and applies therefore in concrete but
+       not in resource modules.
     -optimize=share        share common branches in tables
     -optimize=parametrize  first try parametrize then do share with the rest
     -optimize=values       represent tables as courses-of-values