Layout and type synonyms only

[ghc-hetmet.git] / compiler / hsSyn / HsBinds.lhs

diff --git a/compiler/hsSyn/HsBinds.lhs b/compiler/hsSyn/HsBinds.lhs
index 06a7bcc..86622be 100644 (file)
--- a/compiler/hsSyn/HsBinds.lhs
+++ b/compiler/hsSyn/HsBinds.lhs
@@ -86,7 +86,7 @@ data HsBindLR idL idR
 -- Reason 1: Special case for type inference: see TcBinds.tcMonoBinds
 --
 -- Reason 2: instance decls can only have FunBinds, which is convenient
---          If you change this, you'll need tochange e.g. rnMethodBinds
+--          If you change this, you'll need to change e.g. rnMethodBinds
 
 -- But note that the form      f :: a->a = ...
 -- parses as a pattern binding, just like
@@ -131,8 +131,9 @@ data HsBindLR idL idR
     }
 
   | AbsBinds {                                 -- Binds abstraction; TRANSLATION
-       abs_tvs     :: [TyVar],  
-       abs_dicts   :: [DictId],
+        abs_tvs     :: [TyVar],  
+       abs_dicts   :: [DictId],                -- Includes equality constraints
+
        -- AbsBinds only gets used when idL = idR after renaming,
        -- but these need to be idL's for the collect... code in HsUtil to have
        -- the right type
@@ -338,10 +339,14 @@ data HsWrapper
                                --      = (\a1..an \x1..xn. [])
 
   | WpCast Coercion            -- A cast:  [] `cast` co
-                               -- Guaranteedn not the identity coercion
+                               -- Guaranteed not the identity coercion
+
+  | WpApp Var                  -- [] d         the 'd' is a type-class dictionary or coercion variable
 
-  | WpApp Var                  -- [] d         the 'd' is a type-class dictionary
   | WpTyApp Type               -- [] t         the 't' is a type or corecion
+                               --      ToDo: it'd be tidier if 't' was always a type (not coercion),
+                               --            but that is inconvenient in Inst.instCallDicts
+
   | WpLam Var                  -- \d. []       the 'd' is a type-class dictionary or coercion variable
   | WpTyLam TyVar              -- \a. []       the 'a' is a type variable (not coercion var)
   | WpInline                   -- inline_me []   Wrap inline around the thing
@@ -379,13 +384,13 @@ c1 <.> c2    = c1 `WpCompose` c2
 mkWpTyApps :: [Type] -> HsWrapper
 mkWpTyApps tys = mk_co_fn WpTyApp (reverse tys)
 
-mkWpApps :: [Id] -> HsWrapper
+mkWpApps :: [Var] -> HsWrapper
 mkWpApps ids = mk_co_fn WpApp (reverse ids)
 
 mkWpTyLams :: [TyVar] -> HsWrapper
 mkWpTyLams ids = mk_co_fn WpTyLam ids
 
-mkWpLams :: [Id] -> HsWrapper
+mkWpLams :: [Var] -> HsWrapper
 mkWpLams ids = mk_co_fn WpLam ids
 
 mk_co_fn :: (a -> HsWrapper) -> [a] -> HsWrapper
@@ -465,25 +470,22 @@ isSpecPrag _             = False
 \end{code}
 
 \begin{code}
-okBindSig :: NameSet -> LSig Name -> Bool
-okBindSig ns sig = sigForThisGroup ns sig
+okBindSig :: Sig a -> Bool
+okBindSig _ = True
 
-okHsBootSig :: LSig Name -> Bool
-okHsBootSig (L _ (TypeSig  _ _)) = True
-okHsBootSig (L _ (FixSig _))    = True
-okHsBootSig _                    = False
+okHsBootSig :: Sig a -> Bool
+okHsBootSig (TypeSig  _ _) = True
+okHsBootSig (FixSig _)            = True
+okHsBootSig _              = False
 
-okClsDclSig :: LSig Name -> Bool
-okClsDclSig (L _ (SpecInstSig _)) = False
-okClsDclSig _                     = True        -- All others OK
+okClsDclSig :: Sig a -> Bool
+okClsDclSig (SpecInstSig _) = False
+okClsDclSig _               = True        -- All others OK
 
-okInstDclSig :: NameSet -> LSig Name -> Bool
-okInstDclSig ns lsig@(L _ sig) = ok ns sig
-  where
-    ok _  (TypeSig _ _)   = False
-    ok _  (FixSig _)      = False
-    ok _  (SpecInstSig _) = True
-    ok ns _               = sigForThisGroup ns lsig
+okInstDclSig :: Sig a -> Bool
+okInstDclSig (TypeSig _ _)   = False
+okInstDclSig (FixSig _)      = False
+okInstDclSig _                      = True
 
 sigForThisGroup :: NameSet -> LSig Name -> Bool
 sigForThisGroup ns sig
@@ -539,7 +541,7 @@ hsSigDoc (FixSig {})                = ptext (sLit "fixity declaration")
 Signature equality is used when checking for duplicate signatures
 
 \begin{code}
-eqHsSig :: LSig Name -> LSig Name -> Bool
+eqHsSig :: Eq a => LSig a -> LSig a -> Bool
 eqHsSig (L _ (FixSig (FixitySig n1 _))) (L _ (FixSig (FixitySig n2 _))) = unLoc n1 == unLoc n2
 eqHsSig (L _ (TypeSig n1 _))           (L _ (TypeSig n2 _))            = unLoc n1 == unLoc n2
 eqHsSig (L _ (InlineSig n1 _))          (L _ (InlineSig n2 _))          = unLoc n1 == unLoc n2