overload syntax; type printing in CheckGrammar

3 files changed, 43 insertions, 15 deletions

diff --git a/src/GF/Compile/CheckGrammar.hs b/src/GF/Compile/CheckGrammar.hs
index 9542331b4..cb8c40e5f 100644
--- a/src/GF/Compile/CheckGrammar.hs
+++ b/src/GF/Compile/CheckGrammar.hs
@@ -189,7 +189,9 @@ checkResInfo gr mo (c,info) = do
     ResOverload tysts -> chIn "overloading" $ do
       tysts' <- mapM (uncurry $ flip check) tysts
       ---- TODO: check uniqueness of arg type lists
-      return (c,ResOverload [(y,x) | (x,y) <- tysts'])
+      let tysts2 = [(y,x) | (x,y) <- tysts']
+      checkUniq $ sort [map snd xs | (x,_) <- tysts2, Ok (xs,_) <- [typeFormCnc x]]
+      return (c,ResOverload tysts2)
 
     ResParam (Yes (pcs,_)) -> chIn "parameter type" $ do
 ----      mapM ((mapM (computeLType gr . snd)) . snd) pcs
@@ -204,6 +206,12 @@ checkResInfo gr mo (c,info) = do
    chIn cat = checkIn ("Happened in" +++ cat +++ prt c +++ ":")
    comp = computeLType gr
 
+   checkUniq xss = case xss of
+     x:y:xs 
+      | x == y -> raise $ "ambiguous for argument list" +++ 
+                         unwords (map prtType x)  
+      | otherwise -> checkUniq $ y:xs
+     _ -> return ()
 
 
 checkCncInfo :: SourceGrammar -> Ident -> (Ident,SourceAbs) -> 
@@ -397,7 +405,8 @@ inferLType gr trm = case trm of
                       then return val
                       else substituteLType [(z,a')] val
              return (App f' a',ty) 
-           _ -> prtFail ("function type expected for"+++ prt f +++"instead of") fty
+           _ -> raise ("function type expected for"+++ 
+                      prt f +++"instead of" +++ prtType fty)
 
    S f x -> do
      (f', fty) <- infer f
@@ -573,9 +582,9 @@ inferLType gr trm = case trm of
      let (tts,tys) = unzip ttys
      case lookupOverloadInstance tys typs of
        Just (val,fun) -> return (mkApp fun tts, val)
-       _ -> fail $ "no overload instance of" +++ prt f +++ 
-         "for" +++ unwords (map prt_ tys) +++ "among" ++++ 
-         unlines [unwords (map prt_ ty) | (ty,_) <- typs]
+       _ -> raise $ "no overload instance of" +++ prt f +++ 
+         "for" +++ unwords (map prtType tys) +++ "among" ++++ 
+         unlines [unwords (map prtType ty) | (ty,_) <- typs]
          ++++ "DEBUG" +++ unwords (map show tys) +++ ";" ++++ 
                unlines (map (show . fst) typs) ----
 
@@ -599,7 +608,7 @@ checkLType env trm typ0 = do
                           check c b'
           checkReset
           return $ (Abs x c', Prod x a b')
-        _ -> prtFail "product expected instead of" typ
+        _ -> raise $ "product expected instead of" +++ prtType typ
 
     T _ [] ->
       prtFail "found empty table in type" typ
@@ -617,7 +626,7 @@ checkLType env trm typ0 = do
           _ -> return () -- happens with variable types
         cs' <- mapM (checkCase arg val) cs
         return (T (TTyped arg) cs', typ)
-      _ -> prtFail "table type expected for table instead of" typ
+      _ -> raise $ "table type expected for table instead of" +++ prtType typ
 
     R r -> case typ of --- why needed? because inference may be too difficult
        RecType rr -> do
@@ -672,7 +681,8 @@ checkLType env trm typ0 = do
           (arg',val) <- check arg p
           checkEq typ t trm
           return (S tab' arg', t)
-        _ -> prtFail "table type expected for applied table instead of" ty'
+        _ -> raise $ "table type expected for applied table instead of" +++ 
+                   prtType ty'
      , do
       (arg',ty) <- infer arg
       ty'       <- comp ty
@@ -812,7 +822,8 @@ 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' ++++ show u')
+                ": expected" ++++ prtType t' ++++ 
+                "inferred" ++++ prtType u' ++++ show u')
  where
 
    -- t is a subtype of u 
@@ -873,6 +884,15 @@ checkEqLType env t u trm = do
    sTypes = [typeStr, typeTok, typeString]
    comp = computeLType env
 
+-- printing a type with a lock field lock_C as C
+prtType :: Type -> String
+prtType ty = case ty of
+  RecType fs -> case filter isLockLabel $ map fst fs of
+    [lock] -> drop 5 $ prt lock
+    _ -> prt ty
+  Prod x a b -> prtType a +++ "->" +++ prtType b
+  _ -> prt ty
+
 -- | linearization types and defaults
 linTypeOfType :: SourceGrammar -> Ident -> Type -> Check (Context,Type)
 linTypeOfType cnc m typ = do
diff --git a/src/GF/Source/GrammarToSource.hs b/src/GF/Source/GrammarToSource.hs
index 055c79d15..16a68cdb0 100644
--- a/src/GF/Source/GrammarToSource.hs
+++ b/src/GF/Source/GrammarToSource.hs
@@ -96,7 +96,8 @@ trAnyDef (i,info) = let i' = tri i in case info of
 
   ResOverload tysts -> 
     [P.DefOper [P.DDef [mkName i'] (
-      P.ERecord [P.LDFull [i'] (trt ty) (trt fu) | (ty,fu) <- tysts])]]
+      P.EApp (P.EIdent $ identC "overload") 
+        (P.ERecord [P.LDFull [i'] (trt ty) (trt fu) | (ty,fu) <- tysts]))]]
 
   CncCat (Yes ty) Nope _ -> 
     [P.DefLincat [P.PrintDef [mkName i'] (trt ty)]] 
diff --git a/src/GF/Source/SourceToGrammar.hs b/src/GF/Source/SourceToGrammar.hs
index 49023bf09..7e525a4b9 100644
--- a/src/GF/Source/SourceToGrammar.hs
+++ b/src/GF/Source/SourceToGrammar.hs
@@ -299,7 +299,7 @@ transResDef x = case x of
                      (p,pars) <- pardefs', (f,co) <- pars]
   DefOper defs -> do
     defs' <- liftM concat $ mapM getDefs defs
-    returnl [mkOverload (f, G.ResOper pt pe) | (f,(pt,pe)) <- defs']
+    returnl $ concatMap mkOverload [(f, G.ResOper pt pe) | (f,(pt,pe)) <- defs']
 
   DefLintype defs -> do
     defs' <- liftM concat $ mapM getDefs defs
@@ -309,10 +309,17 @@ transResDef x = case x of
   _ -> Bad $ "illegal definition form in resource" +++ printTree x
  where
    mkOverload (c,j) = case j of
-     G.ResOper Nope (Yes (G.R fs@(_:_:_))) | isOverloading c fs -> 
-       (c,G.ResOverload [(ty,fu) | (_,(Just ty,fu)) <- fs])
-     _ -> (c,j)
-   isOverloading c fs = all (== GP.prt c) (map (GP.prt . fst) fs)
+     G.ResOper _ (Yes (G.App keyw (G.R fs@(_:_:_)))) | 
+                                          isOverloading keyw c fs -> 
+       [(c,G.ResOverload [(ty,fu) | (_,(Just ty,fu)) <- fs])]
+
+     -- to enable separare type signature --- not type-checked
+     G.ResOper (Yes (G.App keyw (G.RecType fs@(_:_:_)))) _ | 
+                                          isOverloading keyw c fs -> []
+     _ -> [(c,j)]
+   isOverloading keyw c fs = 
+     GP.prt keyw == "overload" &&       -- overload is a "soft keyword"
+     all (== GP.prt c) (map (GP.prt . fst) fs)
 
 transParDef :: ParDef -> Err (Ident, [G.Param])
 transParDef x = case x of