Eliminate a warning for compiler/basicTypes/OccName.lhs

[ghc-hetmet.git] / compiler / basicTypes / DataCon.lhs

diff --git a/compiler/basicTypes/DataCon.lhs b/compiler/basicTypes/DataCon.lhs
index 550be30..e5a624f 100644 (file)
--- a/compiler/basicTypes/DataCon.lhs
+++ b/compiler/basicTypes/DataCon.lhs
@@ -12,9 +12,10 @@ module DataCon (
        dataConRepType, dataConSig, dataConFullSig,
        dataConName, dataConIdentity, dataConTag, dataConTyCon, dataConUserType,
        dataConUnivTyVars, dataConExTyVars, dataConAllTyVars, 
        dataConRepType, dataConSig, dataConFullSig,
        dataConName, dataConIdentity, dataConTag, dataConTyCon, dataConUserType,
        dataConUnivTyVars, dataConExTyVars, dataConAllTyVars, 

-       dataConEqSpec, eqSpecPreds, dataConTheta, dataConStupidTheta, 
+       dataConEqSpec, eqSpecPreds, dataConEqTheta, dataConDictTheta, dataConStupidTheta, 

        dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,
        dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,

-       dataConInstOrigArgTys, dataConRepArgTys, 
+       dataConInstOrigArgTys, dataConInstOrigDictsAndArgTys,
+       dataConRepArgTys, 

        dataConFieldLabels, dataConFieldType,
        dataConStrictMarks, dataConExStricts,
        dataConSourceArity, dataConRepArity,
        dataConFieldLabels, dataConFieldType,
        dataConStrictMarks, dataConExStricts,
        dataConSourceArity, dataConRepArity,

@@ -43,11 +44,11 @@ import ListSetOps
 import Util
 import Maybes
 import FastString
 import Util
 import Maybes
 import FastString

-import PackageConfig

 import Module
 
 import Data.Char
 import Data.Word
 import Module
 
 import Data.Char
 import Data.Word

+import Data.List ( partition )

 \end{code}
 
 
 \end{code}
 
 

@@ -86,15 +87,20 @@ differently, as follows.
 
 Note [Data Constructor Naming]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Note [Data Constructor Naming]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-Each data constructor C has two, and possibly three, Names associated with it:
+Each data constructor C has two, and possibly up to four, Names associated with it:

 
 

-                            OccName    Name space      Used for
+                            OccName    Name space      Name of

   ---------------------------------------------------------------------------
   ---------------------------------------------------------------------------

-  * The "source data con"      C       DataName        The DataCon itself
-  * The "real data con"                C       VarName         Its worker Id
-  * The "wrapper data con"     $WC     VarName         Wrapper Id (optional)
-
-Each of these three has a distinct Unique.  The "source data con" name
+  * The "data con itself"      C       DataName        DataCon
+  * The "worker data con"      C       VarName         Id (the worker)
+  * The "wrapper data con"     $WC     VarName         Id (the wrapper)
+  * The "newtype coercion"      :CoT    TcClsName      TyCon
+ 
+EVERY data constructor (incl for newtypes) has the former two (the
+data con itself, and its worker.  But only some data constructors have a
+wrapper (see Note [The need for a wrapper]).
+
+Each of these three has a distinct Unique.  The "data con itself" name

 appears in the output of the renamer, and names the Haskell-source
 data constructor.  The type checker translates it into either the wrapper Id
 (if it exists) or worker Id (otherwise).
 appears in the output of the renamer, and names the Haskell-source
 data constructor.  The type checker translates it into either the wrapper Id
 (if it exists) or worker Id (otherwise).

@@ -128,6 +134,8 @@ The "wrapper Id", $WC, goes as follows
   nothing for the wrapper to do.  That is, if its defn would be
        $wC = C
 
   nothing for the wrapper to do.  That is, if its defn would be
        $wC = C
 

+Note [The need for a wrapper]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Why might the wrapper have anything to do?  Two reasons:
 
 * Unboxing strict fields (with -funbox-strict-fields)
 Why might the wrapper have anything to do?  Two reasons:
 
 * Unboxing strict fields (with -funbox-strict-fields)

@@ -151,6 +159,8 @@ Why might the wrapper have anything to do?  Two reasons:
   The third argument is a coerion
        [a] :: [a]:=:[a]
 
   The third argument is a coerion
        [a] :: [a]:=:[a]
 

+INVARIANT: the dictionary constructor for a class
+          never has a wrapper.

 
 
 A note about the stupid context
 
 
 A note about the stupid context

@@ -224,11 +234,11 @@ data DataCon
        --
        --      *** As declared by the user
        --  data T a where
        --
        --      *** As declared by the user
        --  data T a where

-       --    MkT :: forall x y. (Ord x) => x -> y -> T (x,y)
+       --    MkT :: forall x y. (x~y,Ord x) => x -> y -> T (x,y)

 
        --      *** As represented internally
        --  data T a where
 
        --      *** As represented internally
        --  data T a where

-       --    MkT :: forall a. forall x y. (a:=:(x,y), Ord x) => x -> y -> T a
+       --    MkT :: forall a. forall x y. (a:=:(x,y),x~y,Ord x) => x -> y -> T a

        -- 
        -- The next six fields express the type of the constructor, in pieces
        -- e.g.
        -- 
        -- The next six fields express the type of the constructor, in pieces
        -- e.g.

@@ -236,7 +246,8 @@ data DataCon
        --      dcUnivTyVars  = [a]
        --      dcExTyVars    = [x,y]
        --      dcEqSpec      = [a:=:(x,y)]
        --      dcUnivTyVars  = [a]
        --      dcExTyVars    = [x,y]
        --      dcEqSpec      = [a:=:(x,y)]

-       --      dcTheta       = [Ord x]
+       --      dcEqTheta     = [x~y]   
+       --      dcDictTheta   = [Ord x]

        --      dcOrigArgTys  = [a,List b]
        --      dcRepTyCon       = T
 
        --      dcOrigArgTys  = [a,List b]
        --      dcRepTyCon       = T
 

@@ -244,7 +255,7 @@ data DataCon
                                --          Its type is of form
                                --              forall a1..an . t1 -> ... tm -> T a1..an
                                --          No existentials, no coercions, nothing.
                                --          Its type is of form
                                --              forall a1..an . t1 -> ... tm -> T a1..an
                                --          No existentials, no coercions, nothing.

-                               -- That is: dcExTyVars = dcEqSpec = dcTheta = []
+                               -- That is: dcExTyVars = dcEqSpec = dcEqTheta = dcDictTheta = []

                -- NB 1: newtypes always have a vanilla data con
                -- NB 2: a vanilla constructor can still be declared in GADT-style 
                --       syntax, provided its type looks like the above.
                -- NB 1: newtypes always have a vanilla data con
                -- NB 2: a vanilla constructor can still be declared in GADT-style 
                --       syntax, provided its type looks like the above.

@@ -272,11 +283,14 @@ data DataCon
                -- Each equality is of the form (a :=: ty), where 'a' is one of 
                -- the universally quantified type variables
                                        
                -- Each equality is of the form (a :=: ty), where 'a' is one of 
                -- the universally quantified type variables
                                        

-       dcTheta  :: ThetaType,          -- The context of the constructor
+               -- The next two fields give the type context of the data constructor
+               --      (aside from the GADT constraints, 
+               --       which are given by the dcExpSpec)

                -- In GADT form, this is *exactly* what the programmer writes, even if
                -- the context constrains only universally quantified variables
                -- In GADT form, this is *exactly* what the programmer writes, even if
                -- the context constrains only universally quantified variables

-               --      MkT :: forall a. Eq a => a -> T a
-               -- It may contain user-written equality predicates too
+               --      MkT :: forall a b. (a ~ b, Ord b) => a -> T a b
+       dcEqTheta   :: ThetaType,  -- The *equational* constraints
+       dcDictTheta :: ThetaType,  -- The *type-class and implicit-param* constraints

 
        dcStupidTheta :: ThetaType,     -- The context of the data type declaration 
                                        --      data Eq a => T a = ...
 
        dcStupidTheta :: ThetaType,     -- The context of the data type declaration 
                                        --      data Eq a => T a = ...

@@ -324,19 +338,21 @@ data DataCon
        dcRepTyCon  :: TyCon,           -- Result tycon, T
 
        dcRepType   :: Type,    -- Type of the constructor
        dcRepTyCon  :: TyCon,           -- Result tycon, T
 
        dcRepType   :: Type,    -- Type of the constructor

-                               --      forall a x y. (a:=:(x,y), Ord x) => x -> y -> MkT a
+                               --      forall a x y. (a:=:(x,y), x~y, Ord x) =>
+                                --        x -> y -> T a

                                -- (this is *not* of the constructor wrapper Id:
                                --  see Note [Data con representation] below)
        -- Notice that the existential type parameters come *second*.  
        -- Reason: in a case expression we may find:
                                -- (this is *not* of the constructor wrapper Id:
                                --  see Note [Data con representation] below)
        -- Notice that the existential type parameters come *second*.  
        -- Reason: in a case expression we may find:

-       --      case (e :: T t) of { MkT b (d:Ord b) (x:t) (xs:[b]) -> ... }
+       --      case (e :: T t) of
+        --        MkT x y co1 co2 (d:Ord x) (v:r) (w:F s) -> ...

        -- It's convenient to apply the rep-type of MkT to 't', to get
        -- It's convenient to apply the rep-type of MkT to 't', to get

-       --      forall b. Ord b => ...
+       --      forall x y. (t:=:(x,y), x~y, Ord x) => x -> y -> T t

        -- and use that to check the pattern.  Mind you, this is really only
        -- and use that to check the pattern.  Mind you, this is really only

-       -- use in CoreLint.
+       -- used in CoreLint.

 
 
 
 

-       -- Finally, the curried worker function that corresponds to the constructor
+       -- The curried worker function that corresponds to the constructor:

        -- It doesn't have an unfolding; the code generator saturates these Ids
        -- and allocates a real constructor when it finds one.
        --
        -- It doesn't have an unfolding; the code generator saturates these Ids
        -- and allocates a real constructor when it finds one.
        --

@@ -362,7 +378,7 @@ data DataConIds
        -- The 'Nothing' case of DCIds is important
        -- Not only is this efficient,
        -- but it also ensures that the wrapper is replaced
        -- The 'Nothing' case of DCIds is important
        -- Not only is this efficient,
        -- but it also ensures that the wrapper is replaced

-       -- by the worker (becuase it *is* the worker)
+       -- by the worker (because it *is* the worker)

        -- even when there are no args. E.g. in
        --              f (:) x
        -- the (:) *is* the worker.
        -- even when there are no args. E.g. in
        --              f (:) x
        -- the (:) *is* the worker.

@@ -460,7 +476,7 @@ mkDataCon name declared_infix
 -- so the error is detected properly... it's just that asaertions here
 -- are a little dodgy.
 
 -- so the error is detected properly... it's just that asaertions here
 -- are a little dodgy.
 

-  = ASSERT( not (any isEqPred theta) )
+  = -- ASSERT( not (any isEqPred theta) )

        -- We don't currently allow any equality predicates on
        -- a data constructor (apart from the GADT ones in eq_spec)
     con
        -- We don't currently allow any equality predicates on
        -- a data constructor (apart from the GADT ones in eq_spec)
     con

@@ -470,7 +486,8 @@ mkDataCon name declared_infix
                  dcVanilla = is_vanilla, dcInfix = declared_infix,
                  dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, 
                  dcEqSpec = eq_spec, 
                  dcVanilla = is_vanilla, dcInfix = declared_infix,
                  dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, 
                  dcEqSpec = eq_spec, 

-                 dcStupidTheta = stupid_theta, dcTheta = theta,
+                 dcStupidTheta = stupid_theta, 
+                 dcEqTheta = eq_theta, dcDictTheta = dict_theta,

                  dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
                  dcRepTyCon = tycon, 
                  dcRepArgTys = rep_arg_tys,
                  dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
                  dcRepTyCon = tycon, 
                  dcRepArgTys = rep_arg_tys,

@@ -486,9 +503,10 @@ mkDataCon name declared_infix
        -- The 'arg_stricts' passed to mkDataCon are simply those for the
        -- source-language arguments.  We add extra ones for the
        -- dictionary arguments right here.
        -- The 'arg_stricts' passed to mkDataCon are simply those for the
        -- source-language arguments.  We add extra ones for the
        -- dictionary arguments right here.

-    dict_tys     = mkPredTys theta
-    real_arg_tys = dict_tys                      ++ orig_arg_tys
-    real_stricts = map mk_dict_strict_mark theta ++ arg_stricts
+    (eq_theta,dict_theta)  = partition isEqPred theta
+    dict_tys              = mkPredTys dict_theta
+    real_arg_tys          = dict_tys ++ orig_arg_tys
+    real_stricts          = map mk_dict_strict_mark dict_theta ++ arg_stricts

 
        -- Example
        --   data instance T (b,c) where 
 
        -- Example
        --   data instance T (b,c) where 

@@ -497,6 +515,7 @@ mkDataCon name declared_infix
        -- The representation tycon looks like this:
        --   data :R7T b c where 
        --      TI :: forall b1 c1. (b1 ~ c1) => b1 -> :R7T b1 c1
        -- The representation tycon looks like this:
        --   data :R7T b c where 
        --      TI :: forall b1 c1. (b1 ~ c1) => b1 -> :R7T b1 c1

+       -- In this case orig_res_ty = T (e,e)

     orig_res_ty = mkFamilyTyConApp tycon (substTyVars (mkTopTvSubst eq_spec) univ_tvs)
 
        -- Representation arguments and demands
     orig_res_ty = mkFamilyTyConApp tycon (substTyVars (mkTopTvSubst eq_spec) univ_tvs)
 
        -- Representation arguments and demands

@@ -506,6 +525,7 @@ mkDataCon name declared_infix
     tag = assoc "mkDataCon" (tyConDataCons tycon `zip` [fIRST_TAG..]) con
     ty  = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $ 
          mkFunTys (mkPredTys (eqSpecPreds eq_spec)) $
     tag = assoc "mkDataCon" (tyConDataCons tycon `zip` [fIRST_TAG..]) con
     ty  = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $ 
          mkFunTys (mkPredTys (eqSpecPreds eq_spec)) $

+         mkFunTys (mkPredTys eq_theta) $

                -- NB:  the dict args are already in rep_arg_tys
                --      because they might be flattened..
                --      but the equality predicates are not
                -- NB:  the dict args are already in rep_arg_tys
                --      because they might be flattened..
                --      but the equality predicates are not

@@ -515,6 +535,7 @@ mkDataCon name declared_infix
 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv, ty) | (tv,ty) <- spec ]
 
 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv, ty) | (tv,ty) <- spec ]
 

+mk_dict_strict_mark :: PredType -> StrictnessMark

 mk_dict_strict_mark pred | isStrictPred pred = MarkedStrict
                         | otherwise         = NotMarkedStrict
 \end{code}
 mk_dict_strict_mark pred | isStrictPred pred = MarkedStrict
                         | otherwise         = NotMarkedStrict
 \end{code}

@@ -548,8 +569,11 @@ dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })
 dataConEqSpec :: DataCon -> [(TyVar,Type)]
 dataConEqSpec = dcEqSpec
 
 dataConEqSpec :: DataCon -> [(TyVar,Type)]
 dataConEqSpec = dcEqSpec
 

-dataConTheta :: DataCon -> ThetaType
-dataConTheta = dcTheta
+dataConEqTheta :: DataCon -> ThetaType
+dataConEqTheta = dcEqTheta
+
+dataConDictTheta :: DataCon -> ThetaType
+dataConDictTheta = dcDictTheta

 
 dataConWorkId :: DataCon -> Id
 dataConWorkId dc = case dcIds dc of
 
 dataConWorkId :: DataCon -> Id
 dataConWorkId dc = case dcIds dc of

@@ -585,7 +609,7 @@ dataConStrictMarks = dcStrictMarks
 dataConExStricts :: DataCon -> [StrictnessMark]
 -- Strictness of *existential* arguments only
 -- Usually empty, so we don't bother to cache this
 dataConExStricts :: DataCon -> [StrictnessMark]
 -- Strictness of *existential* arguments only
 -- Usually empty, so we don't bother to cache this

-dataConExStricts dc = map mk_dict_strict_mark (dcTheta dc)
+dataConExStricts dc = map mk_dict_strict_mark $ dcDictTheta dc

 
 dataConSourceArity :: DataCon -> Arity
        -- Source-level arity of the data constructor
 
 dataConSourceArity :: DataCon -> Arity
        -- Source-level arity of the data constructor

@@ -595,6 +619,7 @@ dataConSourceArity dc = length (dcOrigArgTys dc)
 -- {\em representation} of the data constructor.  This may be more than appear
 -- in the source code; the extra ones are the existentially quantified
 -- dictionaries
 -- {\em representation} of the data constructor.  This may be more than appear
 -- in the source code; the extra ones are the existentially quantified
 -- dictionaries

+dataConRepArity :: DataCon -> Int

 dataConRepArity (MkData {dcRepArgTys = arg_tys}) = length arg_tys
 
 isNullarySrcDataCon, isNullaryRepDataCon :: DataCon -> Bool
 dataConRepArity (MkData {dcRepArgTys = arg_tys}) = length arg_tys
 
 isNullarySrcDataCon, isNullaryRepDataCon :: DataCon -> Bool

@@ -608,14 +633,14 @@ dataConRepStrictness dc = dcRepStrictness dc
 
 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
 
 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,

-                   dcTheta  = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
-  = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ theta, arg_tys, res_ty)
+                   dcEqTheta  = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
+  = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ eq_theta ++ dict_theta, arg_tys, res_ty)

 
 dataConFullSig :: DataCon 
 
 dataConFullSig :: DataCon 

-              -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, [Type], Type)
+              -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, ThetaType, [Type], Type)

 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, dcEqSpec = eq_spec,

-                       dcTheta  = theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
-  = (univ_tvs, ex_tvs, eq_spec, theta, arg_tys, res_ty)
+                       dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
+  = (univ_tvs, ex_tvs, eq_spec, eq_theta, dict_theta, arg_tys, res_ty)

 
 dataConOrigResTy :: DataCon -> Type
 dataConOrigResTy dc = dcOrigResTy dc
 
 dataConOrigResTy :: DataCon -> Type
 dataConOrigResTy dc = dcOrigResTy dc

@@ -633,41 +658,60 @@ dataConUserType :: DataCon -> Type
 -- mentions the family tycon, not the internal one.
 dataConUserType  (MkData { dcUnivTyVars = univ_tvs, 
                           dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
 -- mentions the family tycon, not the internal one.
 dataConUserType  (MkData { dcUnivTyVars = univ_tvs, 
                           dcExTyVars = ex_tvs, dcEqSpec = eq_spec,

-                          dcTheta = theta, dcOrigArgTys = arg_tys,
+                          dcEqTheta = eq_theta, dcDictTheta = dict_theta, dcOrigArgTys = arg_tys,

                           dcOrigResTy = res_ty })
   = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $
                           dcOrigResTy = res_ty })
   = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $

-    mkFunTys (mkPredTys theta) $
+    mkFunTys (mkPredTys eq_theta) $
+    mkFunTys (mkPredTys dict_theta) $

     mkFunTys arg_tys $
     res_ty
 
     mkFunTys arg_tys $
     res_ty
 

-dataConInstArgTys :: DataCon
+dataConInstArgTys :: DataCon   -- A datacon with no existentials or equality constraints
+                               -- However, it can have a dcTheta (notably it can be a 
+                               -- class dictionary, with superclasses)

                  -> [Type]     -- Instantiated at these types
                  -> [Type]     -- Instantiated at these types

-                               -- NB: these INCLUDE the existentially quantified arg types

                  -> [Type]     -- Needs arguments of these types
                  -> [Type]     -- Needs arguments of these types

-                               -- NB: these INCLUDE the existentially quantified dict args
+                               -- NB: these INCLUDE any dict args

                                --     but EXCLUDE the data-decl context which is discarded
                                -- It's all post-flattening etc; this is a representation type
                                --     but EXCLUDE the data-decl context which is discarded
                                -- It's all post-flattening etc; this is a representation type

-dataConInstArgTys dc@(MkData {dcRepArgTys = arg_tys, 
-                             dcUnivTyVars = univ_tvs, 
+dataConInstArgTys dc@(MkData {dcRepArgTys = rep_arg_tys, 
+                             dcUnivTyVars = univ_tvs, dcEqSpec = eq_spec,

                              dcExTyVars = ex_tvs}) inst_tys
                              dcExTyVars = ex_tvs}) inst_tys

- = ASSERT2 ( length tyvars == length inst_tys 
-           , ptext SLIT("dataConInstArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys)
-           
-   map (substTyWith tyvars inst_tys) arg_tys
- where
-   tyvars = univ_tvs ++ ex_tvs
-
-
--- And the same deal for the original arg tys
-dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]
+ = ASSERT2 ( length univ_tvs == length inst_tys 
+           , ptext (sLit "dataConInstArgTys") <+> ppr dc $$ ppr univ_tvs $$ ppr inst_tys)
+   ASSERT2 ( null ex_tvs && null eq_spec, ppr dc )        
+   map (substTyWith univ_tvs inst_tys) rep_arg_tys
+
+dataConInstOrigArgTys 
+       :: DataCon      -- Works for any DataCon
+       -> [Type]       -- Includes existential tyvar args, but NOT
+                       -- equality constraints or dicts
+       -> [Type]       -- Returns just the instsantiated *value* arguments
+-- For vanilla datacons, it's all quite straightforward
+-- But for the call in MatchCon, we really do want just the value args

 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
                                  dcUnivTyVars = univ_tvs, 
                                  dcExTyVars = ex_tvs}) inst_tys
 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
                                  dcUnivTyVars = univ_tvs, 
                                  dcExTyVars = ex_tvs}) inst_tys

- = ASSERT2( length tyvars == length inst_tys
-          , ptext SLIT("dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
-   map (substTyWith tyvars inst_tys) arg_tys
- where
-   tyvars = univ_tvs ++ ex_tvs
+  = ASSERT2( length tyvars == length inst_tys
+          , ptext (sLit "dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
+    map (substTyWith tyvars inst_tys) arg_tys
+  where
+    tyvars = univ_tvs ++ ex_tvs
+
+dataConInstOrigDictsAndArgTys 
+       :: DataCon      -- Works for any DataCon
+       -> [Type]       -- Includes existential tyvar args, but NOT
+                       -- equality constraints or dicts
+       -> [Type]       -- Returns just the instsantiated dicts and *value* arguments
+dataConInstOrigDictsAndArgTys dc@(MkData {dcOrigArgTys = arg_tys,
+                                 dcDictTheta = dicts,       
+                                 dcUnivTyVars = univ_tvs, 
+                                 dcExTyVars = ex_tvs}) inst_tys
+  = ASSERT2( length tyvars == length inst_tys
+          , ptext (sLit "dataConInstOrigDictsAndArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
+    map (substTyWith tyvars inst_tys) (mkPredTys dicts ++ arg_tys)
+  where
+    tyvars = univ_tvs ++ ex_tvs

 \end{code}
 
 These two functions get the real argument types of the constructor,
 \end{code}
 
 These two functions get the real argument types of the constructor,

@@ -752,25 +796,29 @@ splitProductType_maybe ty
           where
              data_con = ASSERT( not (null (tyConDataCons tycon)) ) 
                         head (tyConDataCons tycon)
           where
              data_con = ASSERT( not (null (tyConDataCons tycon)) ) 
                         head (tyConDataCons tycon)

-       other -> Nothing
+       _other -> Nothing

 
 

+splitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])

 splitProductType str ty
   = case splitProductType_maybe ty of
        Just stuff -> stuff
        Nothing    -> pprPanic (str ++ ": not a product") (pprType ty)
 
 
 splitProductType str ty
   = case splitProductType_maybe ty of
        Just stuff -> stuff
        Nothing    -> pprPanic (str ++ ": not a product") (pprType ty)
 
 

+deepSplitProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Type])

 deepSplitProductType_maybe ty
   = do { (res@(tycon, tycon_args, _, _)) <- splitProductType_maybe ty
        ; let {result 
 deepSplitProductType_maybe ty
   = do { (res@(tycon, tycon_args, _, _)) <- splitProductType_maybe ty
        ; let {result 

-             | isClosedNewTyCon tycon && not (isRecursiveTyCon tycon)
-             = deepSplitProductType_maybe (newTyConInstRhs tycon tycon_args)
+             | Just (ty', _co) <- instNewTyCon_maybe tycon tycon_args
+            , not (isRecursiveTyCon tycon)
+             = deepSplitProductType_maybe ty'  -- Ignore the coercion?

              | isNewTyCon tycon = Nothing  -- cannot unbox through recursive
                                           -- newtypes nor through families
              | otherwise = Just res}
        ; result
        }
           
              | isNewTyCon tycon = Nothing  -- cannot unbox through recursive
                                           -- newtypes nor through families
              | otherwise = Just res}
        ; result
        }
           

+deepSplitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])

 deepSplitProductType str ty 
   = case deepSplitProductType_maybe ty of
       Just stuff -> stuff
 deepSplitProductType str ty 
   = case deepSplitProductType_maybe ty of
       Just stuff -> stuff