Fix scoped type variables for expression type signatures

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

diff --git a/compiler/hsSyn/HsDecls.lhs b/compiler/hsSyn/HsDecls.lhs
index 90479ab..2128ad3 100644 (file)
--- a/compiler/hsSyn/HsDecls.lhs
+++ b/compiler/hsSyn/HsDecls.lhs
@@ -18,7 +18,8 @@ module HsDecls (
        DeprecDecl(..),  LDeprecDecl,
        HsGroup(..),  emptyRdrGroup, emptyRnGroup, appendGroups,
        tcdName, tyClDeclNames, tyClDeclTyVars,
        DeprecDecl(..),  LDeprecDecl,
        HsGroup(..),  emptyRdrGroup, emptyRnGroup, appendGroups,
        tcdName, tyClDeclNames, tyClDeclTyVars,

-       isClassDecl, isTFunDecl, isSynDecl, isTEqnDecl, isDataDecl, 
+       isClassDecl, isTFunDecl, isSynDecl, isDataDecl, isKindSigDecl,
+       isIdxTyDecl,

        countTyClDecls,
        conDetailsTys,
        instDeclATs,
        countTyClDecls,
        conDetailsTys,
        instDeclATs,

@@ -38,20 +39,19 @@ import HsPat                ( HsConDetails(..), hsConArgs )
 import HsImpExp                ( pprHsVar )
 import HsTypes
 import NameSet          ( NameSet )
 import HsImpExp                ( pprHsVar )
 import HsTypes
 import NameSet          ( NameSet )

-import HscTypes                ( DeprecTxt )

 import CoreSyn         ( RuleName )
 import CoreSyn         ( RuleName )

-import Kind            ( Kind, pprKind )
-import BasicTypes      ( Activation(..) )
+import {- Kind parts of -} Type                ( Kind, pprKind )
+import BasicTypes      ( Activation(..), DeprecTxt )

 import ForeignCall     ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
                          CExportSpec(..), CLabelString ) 
 
 -- others:
 import ForeignCall     ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
                          CExportSpec(..), CLabelString ) 
 
 -- others:

-import FunDeps         ( pprFundeps )
-import Class           ( FunDep )
+import Class           ( FunDep, pprFundeps )

 import Outputable      
 import Util            ( count )
 import SrcLoc          ( Located(..), unLoc, noLoc )
 import FastString
 import Outputable      
 import Util            ( count )
 import SrcLoc          ( Located(..), unLoc, noLoc )
 import FastString

+import Maybe            ( isJust )

 \end{code}
 
 
 \end{code}
 
 

@@ -329,21 +329,28 @@ Interface file code:
 -- for a module.  That's why (despite the misnomer) IfaceSig and ForeignType
 -- are both in TyClDecl
 
 -- for a module.  That's why (despite the misnomer) IfaceSig and ForeignType
 -- are both in TyClDecl
 

--- Representation of type functions and associated data types & synonyms
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--- 'TyData' and 'TySynonym' have a field 'tcdPats::Maybe [LHsType name]', with
--- the following meaning:
+-- Representation of indexed types
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Kind signatures of indexed types come in two flavours:
+--
+-- * kind signatures for type functions: variant `TyFunction' and
+--
+-- * kind signatures for indexed data types and newtypes : variant `TyData'
+--   iff a kind is present in `tcdKindSig' and there are no constructors in
+--   `tcdCons'.
+--
+-- Indexed types are represented by 'TyData' and 'TySynonym' using the field
+-- 'tcdTyPats::Maybe [LHsType name]', with the following meaning:

 --
 --   * If it is 'Nothing', we have a *vanilla* data type declaration or type
 --     synonym declaration and 'tcdVars' contains the type parameters of the
 --     type constructor.
 --
 --
 --   * If it is 'Nothing', we have a *vanilla* data type declaration or type
 --     synonym declaration and 'tcdVars' contains the type parameters of the
 --     type constructor.
 --

---   * If it is 'Just pats', we have the definition of an associated data type
---     or a type function equations (toplevel or nested in an instance
---     declarations).  Then, 'pats' are type patterns for the type-indexes of
---     the type constructor and 'tcdVars' are the variables in those
---     patterns.  Hence, the arity of the type constructor is 'length tcdPats'
---     and *not* 'length tcdVars'.
+--   * If it is 'Just pats', we have the definition of an indexed type Then,
+--     'pats' are type patterns for the type-indexes of the type constructor
+--     and 'tcdVars' are the variables in those patterns.  Hence, the arity of
+--     the indexed type (ie, the number of indexes) is 'length tcdTyPats' and
+--     *not* 'length tcdVars'.

 --
 -- In both cases, 'tcdVars' collects all variables we need to quantify over.
 
 --
 -- In both cases, 'tcdVars' collects all variables we need to quantify over.
 

@@ -414,7 +421,7 @@ data NewOrData
 Simple classifiers
 
 \begin{code}
 Simple classifiers
 
 \begin{code}

-isTFunDecl, isDataDecl, isSynDecl, isTEqnDecl, isClassDecl :: 
+isTFunDecl, isDataDecl, isSynDecl, isClassDecl, isKindSigDecl, isIdxTyDecl ::

   TyClDecl name -> Bool
 
 -- type function kind signature
   TyClDecl name -> Bool
 
 -- type function kind signature

@@ -434,6 +441,18 @@ isDataDecl other       = False
 
 isClassDecl (ClassDecl {}) = True
 isClassDecl other         = False
 
 isClassDecl (ClassDecl {}) = True
 isClassDecl other         = False

+
+-- kind signature (for an indexed type)
+isKindSigDecl (TyFunction {}                   ) = True
+isKindSigDecl (TyData     {tcdKindSig = Just _,
+                          tcdCons    = []    }) = True
+isKindSigDecl other                              = False
+
+-- definition of an instance of an indexed type
+isIdxTyDecl tydecl
+   | isTEqnDecl tydecl = True
+   | isDataDecl tydecl = isJust (tcdTyPats tydecl)
+   | otherwise        = False

 \end{code}
 
 Dealing with names
 \end{code}
 
 Dealing with names

@@ -449,9 +468,7 @@ tyClDeclNames :: Eq name => TyClDecl name -> [Located name]
 -- We use the equality to filter out duplicate field names
 
 tyClDeclNames (TyFunction  {tcdLName = name})    = [name]
 -- We use the equality to filter out duplicate field names
 
 tyClDeclNames (TyFunction  {tcdLName = name})    = [name]

-tyClDeclNames (TySynonym   {tcdLName = name,
-                           tcdTyPats= Nothing}) = [name]
-tyClDeclNames (TySynonym   {}                  ) = []     -- type equation
+tyClDeclNames (TySynonym   {tcdLName = name})    = [name]

 tyClDeclNames (ForeignType {tcdLName = name})    = [name]
 
 tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs, tcdATs = ats})
 tyClDeclNames (ForeignType {tcdLName = name})    = [name]
 
 tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs, tcdATs = ats})

@@ -500,19 +517,23 @@ instance OutputableBndr name
        dcolon <+> pprKind kind
         where
          typeMaybeIso = if iso 
        dcolon <+> pprKind kind
         where
          typeMaybeIso = if iso 

-                        then ptext SLIT("type iso") 
-                        else ptext SLIT("type")
+                        then ptext SLIT("type family iso") 
+                        else ptext SLIT("type family")

 
     ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdTyPats = typats,
                    tcdSynRhs = mono_ty})
 
     ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdTyPats = typats,
                    tcdSynRhs = mono_ty})

-      = hang (ptext SLIT("type") <+> pp_decl_head [] ltycon tyvars typats <+> 
+      = hang (ptext SLIT("type") <+> 
+             (if isJust typats then ptext SLIT("instance") else empty) <+>
+             pp_decl_head [] ltycon tyvars typats <+> 

              equals)
             4 (ppr mono_ty)
 
     ppr (TyData {tcdND = new_or_data, tcdCtxt = context, tcdLName = ltycon,
                 tcdTyVars = tyvars, tcdTyPats = typats, tcdKindSig = mb_sig, 
                 tcdCons = condecls, tcdDerivs = derivings})
              equals)
             4 (ppr mono_ty)
 
     ppr (TyData {tcdND = new_or_data, tcdCtxt = context, tcdLName = ltycon,
                 tcdTyVars = tyvars, tcdTyPats = typats, tcdKindSig = mb_sig, 
                 tcdCons = condecls, tcdDerivs = derivings})

-      = pp_tydecl (ppr new_or_data <+> 
+      = pp_tydecl (null condecls && isJust mb_sig) 
+                  (ppr new_or_data <+> 
+                  (if isJust typats then ptext SLIT("instance") else empty) <+>

                   pp_decl_head (unLoc context) ltycon tyvars typats <+> 
                   ppr_sig mb_sig)
                  (pp_condecls condecls)
                   pp_decl_head (unLoc context) ltycon tyvars typats <+> 
                   ppr_sig mb_sig)
                  (pp_condecls condecls)

@@ -556,12 +577,14 @@ pp_condecls cs@(L _ ConDecl{ con_res = ResTyGADT _ } : _) -- In GADT syntax
 pp_condecls cs                           -- In H98 syntax
   = equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
 
 pp_condecls cs                           -- In H98 syntax
   = equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
 

-pp_tydecl pp_head pp_decl_rhs derivings
+pp_tydecl True pp_head pp_decl_rhs derivings
+  = pp_head
+pp_tydecl False pp_head pp_decl_rhs derivings

   = hang pp_head 4 (sep [
   = hang pp_head 4 (sep [

-       pp_decl_rhs,
-       case derivings of
-         Nothing          -> empty
-         Just ds          -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]
+      pp_decl_rhs,
+      case derivings of
+        Nothing -> empty
+       Just ds -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]

     ])
 
 instance Outputable NewOrData where
     ])
 
 instance Outputable NewOrData where