Make {-# UNPACK #-} work for type/data family invocations
[ghc.git] / compiler / basicTypes / DataCon.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1998
4 %
5 \section[DataCon]{@DataCon@: Data Constructors}
6
7 \begin{code}
8 {-# OPTIONS -fno-warn-tabs #-}
9 -- The above warning supression flag is a temporary kludge.
10 -- While working on this module you are encouraged to remove it and
11 -- detab the module (please do the detabbing in a separate patch). See
12 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
13 -- for details
14
15 module DataCon (
16         -- * Main data types
17         DataCon, DataConRep(..), HsBang(..), StrictnessMark(..),
18         ConTag,
19         
20         -- ** Type construction
21         mkDataCon, fIRST_TAG,
22         
23         -- ** Type deconstruction
24         dataConRepType, dataConSig, dataConFullSig,
25         dataConName, dataConIdentity, dataConTag, dataConTyCon, 
26         dataConOrigTyCon, dataConUserType,
27         dataConUnivTyVars, dataConExTyVars, dataConAllTyVars, 
28         dataConEqSpec, eqSpecPreds, dataConTheta,
29         dataConStupidTheta,  
30         dataConInstArgTys, dataConOrigArgTys, dataConOrigResTy,
31         dataConInstOrigArgTys, dataConRepArgTys, 
32         dataConFieldLabels, dataConFieldType,
33         dataConStrictMarks, 
34         dataConSourceArity, dataConRepArity, dataConRepRepArity,
35         dataConIsInfix,
36         dataConWorkId, dataConWrapId, dataConWrapId_maybe, dataConImplicitIds,
37         dataConRepStrictness, dataConRepBangs, dataConBoxer,
38         
39         -- ** Predicates on DataCons
40         isNullarySrcDataCon, isNullaryRepDataCon, isTupleDataCon, isUnboxedTupleCon,
41         isVanillaDataCon, classDataCon, dataConCannotMatch,
42         isBanged, isMarkedStrict, eqHsBang,
43
44         -- * Splitting product types
45         splitProductType_maybe, splitProductType, 
46
47         -- ** Promotion related functions
48         isPromotableTyCon, promoteTyCon, 
49         promoteDataCon, promoteDataCon_maybe
50     ) where
51
52 #include "HsVersions.h"
53
54 import {-# SOURCE #-} MkId( DataConBoxer )
55 import Type
56 import TypeRep( Type(..) )  -- Used in promoteType
57 import PrelNames( liftedTypeKindTyConKey )
58 import Coercion
59 import Kind
60 import Unify
61 import TyCon
62 import Class
63 import Name
64 import Var
65 import Outputable
66 import Unique
67 import ListSetOps
68 import Util
69 import BasicTypes
70 import FastString
71 import Module
72 import VarEnv
73
74 import qualified Data.Data as Data
75 import qualified Data.Typeable
76 import Data.Char
77 import Data.Word
78 \end{code}
79
80
81 Data constructor representation
82 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
83 Consider the following Haskell data type declaration
84
85         data T = T !Int ![Int]
86
87 Using the strictness annotations, GHC will represent this as
88
89         data T = T Int# [Int]
90
91 That is, the Int has been unboxed.  Furthermore, the Haskell source construction
92
93         T e1 e2
94
95 is translated to
96
97         case e1 of { I# x -> 
98         case e2 of { r ->
99         T x r }}
100
101 That is, the first argument is unboxed, and the second is evaluated.  Finally,
102 pattern matching is translated too:
103
104         case e of { T a b -> ... }
105
106 becomes
107
108         case e of { T a' b -> let a = I# a' in ... }
109
110 To keep ourselves sane, we name the different versions of the data constructor
111 differently, as follows.
112
113
114 Note [Data Constructor Naming]
115 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
116 Each data constructor C has two, and possibly up to four, Names associated with it:
117
118                    OccName   Name space   Name of   Notes
119  ---------------------------------------------------------------------------
120  The "data con itself"   C     DataName   DataCon   In dom( GlobalRdrEnv )
121  The "worker data con"   C     VarName    Id        The worker
122  The "wrapper data con"  $WC   VarName    Id        The wrapper
123  The "newtype coercion"  :CoT  TcClsName  TyCon
124  
125 EVERY data constructor (incl for newtypes) has the former two (the
126 data con itself, and its worker.  But only some data constructors have a
127 wrapper (see Note [The need for a wrapper]).
128
129 Each of these three has a distinct Unique.  The "data con itself" name
130 appears in the output of the renamer, and names the Haskell-source
131 data constructor.  The type checker translates it into either the wrapper Id
132 (if it exists) or worker Id (otherwise).
133
134 The data con has one or two Ids associated with it:
135
136 The "worker Id", is the actual data constructor.
137 * Every data constructor (newtype or data type) has a worker
138
139 * The worker is very like a primop, in that it has no binding.
140
141 * For a *data* type, the worker *is* the data constructor;
142   it has no unfolding
143
144 * For a *newtype*, the worker has a compulsory unfolding which 
145   does a cast, e.g.
146         newtype T = MkT Int
147         The worker for MkT has unfolding
148                 \\(x:Int). x `cast` sym CoT
149   Here CoT is the type constructor, witnessing the FC axiom
150         axiom CoT : T = Int
151
152 The "wrapper Id", \$WC, goes as follows
153
154 * Its type is exactly what it looks like in the source program. 
155
156 * It is an ordinary function, and it gets a top-level binding 
157   like any other function.
158
159 * The wrapper Id isn't generated for a data type if there is
160   nothing for the wrapper to do.  That is, if its defn would be
161         \$wC = C
162
163 Note [The need for a wrapper]
164 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
165 Why might the wrapper have anything to do?  Two reasons:
166
167 * Unboxing strict fields (with -funbox-strict-fields)
168         data T = MkT !(Int,Int)
169         \$wMkT :: (Int,Int) -> T
170         \$wMkT (x,y) = MkT x y
171   Notice that the worker has two fields where the wapper has 
172   just one.  That is, the worker has type
173                 MkT :: Int -> Int -> T
174
175 * Equality constraints for GADTs
176         data T a where { MkT :: a -> T [a] }
177
178   The worker gets a type with explicit equality
179   constraints, thus:
180         MkT :: forall a b. (a=[b]) => b -> T a
181
182   The wrapper has the programmer-specified type:
183         \$wMkT :: a -> T [a]
184         \$wMkT a x = MkT [a] a [a] x
185   The third argument is a coerion
186         [a] :: [a]~[a]
187
188 INVARIANT: the dictionary constructor for a class
189            never has a wrapper.
190
191
192 A note about the stupid context
193 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
194 Data types can have a context:
195         
196         data (Eq a, Ord b) => T a b = T1 a b | T2 a
197
198 and that makes the constructors have a context too
199 (notice that T2's context is "thinned"):
200
201         T1 :: (Eq a, Ord b) => a -> b -> T a b
202         T2 :: (Eq a) => a -> T a b
203
204 Furthermore, this context pops up when pattern matching
205 (though GHC hasn't implemented this, but it is in H98, and
206 I've fixed GHC so that it now does):
207
208         f (T2 x) = x
209 gets inferred type
210         f :: Eq a => T a b -> a
211
212 I say the context is "stupid" because the dictionaries passed
213 are immediately discarded -- they do nothing and have no benefit.
214 It's a flaw in the language.
215
216         Up to now [March 2002] I have put this stupid context into the
217         type of the "wrapper" constructors functions, T1 and T2, but
218         that turned out to be jolly inconvenient for generics, and
219         record update, and other functions that build values of type T
220         (because they don't have suitable dictionaries available).
221
222         So now I've taken the stupid context out.  I simply deal with
223         it separately in the type checker on occurrences of a
224         constructor, either in an expression or in a pattern.
225
226         [May 2003: actually I think this decision could evasily be
227         reversed now, and probably should be.  Generics could be
228         disabled for types with a stupid context; record updates now
229         (H98) needs the context too; etc.  It's an unforced change, so
230         I'm leaving it for now --- but it does seem odd that the
231         wrapper doesn't include the stupid context.]
232
233 [July 04] With the advent of generalised data types, it's less obvious
234 what the "stupid context" is.  Consider
235         C :: forall a. Ord a => a -> a -> T (Foo a)
236 Does the C constructor in Core contain the Ord dictionary?  Yes, it must:
237
238         f :: T b -> Ordering
239         f = /\b. \x:T b. 
240             case x of
241                 C a (d:Ord a) (p:a) (q:a) -> compare d p q
242
243 Note that (Foo a) might not be an instance of Ord.
244
245 %************************************************************************
246 %*                                                                      *
247 \subsection{Data constructors}
248 %*                                                                      *
249 %************************************************************************
250
251 \begin{code}
252 -- | A data constructor
253 data DataCon
254   = MkData {
255         dcName    :: Name,      -- This is the name of the *source data con*
256                                 -- (see "Note [Data Constructor Naming]" above)
257         dcUnique :: Unique,     -- Cached from Name
258         dcTag    :: ConTag,     -- ^ Tag, used for ordering 'DataCon's
259
260         -- Running example:
261         --
262         --      *** As declared by the user
263         --  data T a where
264         --    MkT :: forall x y. (x~y,Ord x) => x -> y -> T (x,y)
265
266         --      *** As represented internally
267         --  data T a where
268         --    MkT :: forall a. forall x y. (a~(x,y),x~y,Ord x) => x -> y -> T a
269         -- 
270         -- The next six fields express the type of the constructor, in pieces
271         -- e.g.
272         --
273         --      dcUnivTyVars  = [a]
274         --      dcExTyVars    = [x,y]
275         --      dcEqSpec      = [a~(x,y)]
276         --      dcOtherTheta  = [x~y, Ord x]    
277         --      dcOrigArgTys  = [x,y]
278         --      dcRepTyCon       = T
279
280         dcVanilla :: Bool,      -- True <=> This is a vanilla Haskell 98 data constructor
281                                 --          Its type is of form
282                                 --              forall a1..an . t1 -> ... tm -> T a1..an
283                                 --          No existentials, no coercions, nothing.
284                                 -- That is: dcExTyVars = dcEqSpec = dcOtherTheta = []
285                 -- NB 1: newtypes always have a vanilla data con
286                 -- NB 2: a vanilla constructor can still be declared in GADT-style 
287                 --       syntax, provided its type looks like the above.
288                 --       The declaration format is held in the TyCon (algTcGadtSyntax)
289
290         dcUnivTyVars :: [TyVar],        -- Universally-quantified type vars [a,b,c]
291                                         -- INVARIANT: length matches arity of the dcRepTyCon
292                                         ---           result type of (rep) data con is exactly (T a b c)
293
294         dcExTyVars   :: [TyVar],        -- Existentially-quantified type vars 
295                 -- In general, the dcUnivTyVars are NOT NECESSARILY THE SAME AS THE TYVARS
296                 -- FOR THE PARENT TyCon. With GADTs the data con might not even have 
297                 -- the same number of type variables.
298                 -- [This is a change (Oct05): previously, vanilla datacons guaranteed to
299                 --  have the same type variables as their parent TyCon, but that seems ugly.]
300
301         -- INVARIANT: the UnivTyVars and ExTyVars all have distinct OccNames
302         -- Reason: less confusing, and easier to generate IfaceSyn
303
304         dcEqSpec :: [(TyVar,Type)],     -- Equalities derived from the result type, 
305                                         -- _as written by the programmer_
306                 -- This field allows us to move conveniently between the two ways
307                 -- of representing a GADT constructor's type:
308                 --      MkT :: forall a b. (a ~ [b]) => b -> T a
309                 --      MkT :: forall b. b -> T [b]
310                 -- Each equality is of the form (a ~ ty), where 'a' is one of 
311                 -- the universally quantified type variables
312                                         
313                 -- The next two fields give the type context of the data constructor
314                 --      (aside from the GADT constraints, 
315                 --       which are given by the dcExpSpec)
316                 -- In GADT form, this is *exactly* what the programmer writes, even if
317                 -- the context constrains only universally quantified variables
318                 --      MkT :: forall a b. (a ~ b, Ord b) => a -> T a b
319         dcOtherTheta :: ThetaType,  -- The other constraints in the data con's type
320                                     -- other than those in the dcEqSpec
321
322         dcStupidTheta :: ThetaType,     -- The context of the data type declaration 
323                                         --      data Eq a => T a = ...
324                                         -- or, rather, a "thinned" version thereof
325                 -- "Thinned", because the Report says
326                 -- to eliminate any constraints that don't mention
327                 -- tyvars free in the arg types for this constructor
328                 --
329                 -- INVARIANT: the free tyvars of dcStupidTheta are a subset of dcUnivTyVars
330                 -- Reason: dcStupidTeta is gotten by thinning the stupid theta from the tycon
331                 -- 
332                 -- "Stupid", because the dictionaries aren't used for anything.  
333                 -- Indeed, [as of March 02] they are no longer in the type of 
334                 -- the wrapper Id, because that makes it harder to use the wrap-id 
335                 -- to rebuild values after record selection or in generics.
336
337         dcOrigArgTys :: [Type],         -- Original argument types
338                                         -- (before unboxing and flattening of strict fields)
339         dcOrigResTy :: Type,            -- Original result type, as seen by the user
340                 -- NB: for a data instance, the original user result type may 
341                 -- differ from the DataCon's representation TyCon.  Example
342                 --      data instance T [a] where MkT :: a -> T [a]
343                 -- The OrigResTy is T [a], but the dcRepTyCon might be :T123
344
345         -- Now the strictness annotations and field labels of the constructor
346         -- See Note [Bangs on data constructor arguments]
347         dcArgBangs :: [HsBang],
348                 -- Strictness annotations as decided by the compiler.  
349                 -- Matches 1-1 with dcOrigArgTys
350                 -- Hence length = dataConSourceArity dataCon
351
352         dcFields  :: [FieldLabel],
353                 -- Field labels for this constructor, in the
354                 -- same order as the dcOrigArgTys; 
355                 -- length = 0 (if not a record) or dataConSourceArity.
356
357         -- The curried worker function that corresponds to the constructor:
358         -- It doesn't have an unfolding; the code generator saturates these Ids
359         -- and allocates a real constructor when it finds one.
360         dcWorkId :: Id,
361
362         -- Constructor representation
363         dcRep      :: DataConRep,
364
365         -- Cached
366         dcRepArity    :: Arity,  -- == length dataConRepArgTys
367         dcSourceArity :: Arity,  -- == length dcOrigArgTys
368
369         -- Result type of constructor is T t1..tn
370         dcRepTyCon  :: TyCon,           -- Result tycon, T
371
372         dcRepType   :: Type,    -- Type of the constructor
373                                 --      forall a x y. (a~(x,y), x~y, Ord x) =>
374                                 --        x -> y -> T a
375                                 -- (this is *not* of the constructor wrapper Id:
376                                 --  see Note [Data con representation] below)
377         -- Notice that the existential type parameters come *second*.  
378         -- Reason: in a case expression we may find:
379         --      case (e :: T t) of
380         --        MkT x y co1 co2 (d:Ord x) (v:r) (w:F s) -> ...
381         -- It's convenient to apply the rep-type of MkT to 't', to get
382         --      forall x y. (t~(x,y), x~y, Ord x) => x -> y -> T t
383         -- and use that to check the pattern.  Mind you, this is really only
384         -- used in CoreLint.
385
386
387         dcInfix :: Bool,        -- True <=> declared infix
388                                 -- Used for Template Haskell and 'deriving' only
389                                 -- The actual fixity is stored elsewhere
390
391         dcPromoted :: Maybe TyCon    -- The promoted TyCon if this DataCon is promotable
392                                      -- See Note [Promoted data constructors] in TyCon
393   }
394   deriving Data.Typeable.Typeable
395
396 data DataConRep 
397   = NoDataConRep              -- No wrapper
398
399   | DCR { dcr_wrap_id :: Id   -- Takes src args, unboxes/flattens, 
400                               -- and constructs the representation
401
402         , dcr_boxer   :: DataConBoxer
403
404         , dcr_arg_tys :: [Type]  -- Final, representation argument types, 
405                                  -- after unboxing and flattening,
406                                  -- and *including* all evidence args
407
408         , dcr_stricts :: [StrictnessMark]  -- 1-1 with dcr_arg_tys
409                 -- See also Note [Data-con worker strictness] in MkId.lhs
410
411         , dcr_bangs :: [HsBang]  -- The actual decisions made (including failures)
412                                  -- 1-1 with orig_arg_tys
413                                  -- See Note [Bangs on data constructor arguments]
414
415     }
416 -- Algebraic data types always have a worker, and
417 -- may or may not have a wrapper, depending on whether
418 -- the wrapper does anything.  
419 --
420 -- Data types have a worker with no unfolding
421 -- Newtypes just have a worker, which has a compulsory unfolding (just a cast)
422
423 -- _Neither_ the worker _nor_ the wrapper take the dcStupidTheta dicts as arguments
424
425 -- The wrapper (if it exists) takes dcOrigArgTys as its arguments
426 -- The worker takes dataConRepArgTys as its arguments
427 -- If the worker is absent, dataConRepArgTys is the same as dcOrigArgTys
428
429 -- The 'NoDataConRep' case is important
430 -- Not only is this efficient,
431 -- but it also ensures that the wrapper is replaced
432 -- by the worker (because it *is* the worker)
433 -- even when there are no args. E.g. in
434 --              f (:) x
435 -- the (:) *is* the worker.
436 -- This is really important in rule matching,
437 -- (We could match on the wrappers,
438 -- but that makes it less likely that rules will match
439 -- when we bring bits of unfoldings together.)
440
441 -------------------------
442 -- HsBang describes what the *programmer* wrote
443 -- This info is retained in the DataCon.dcStrictMarks field
444 data HsBang 
445   = HsNoBang           -- Lazy field
446
447   | HsBang Bool      -- Source-language '!' bang
448                      --  True <=> also an {-# UNPACK #-} pragma
449
450   | HsUnpack              -- Definite commitment: this field is strict and unboxed
451        (Maybe Coercion)   --    co :: arg-ty ~ product-ty
452
453   | HsStrict            -- Definite commitment: this field is strict but not unboxed
454   deriving (Data.Data, Data.Typeable)
455
456 -------------------------
457 -- StrictnessMark is internal only, used to indicate strictness 
458 -- of the DataCon *worker* fields
459 data StrictnessMark = MarkedStrict | NotMarkedStrict    
460
461 -- | Type of the tags associated with each constructor possibility
462 type ConTag = Int
463
464 fIRST_TAG :: ConTag
465 -- ^ Tags are allocated from here for real constructors
466 fIRST_TAG =  1
467 \end{code}
468
469 Note [Data con representation]
470 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
471 The dcRepType field contains the type of the representation of a contructor
472 This may differ from the type of the contructor *Id* (built
473 by MkId.mkDataConId) for two reasons:
474         a) the constructor Id may be overloaded, but the dictionary isn't stored
475            e.g.    data Eq a => T a = MkT a a
476
477         b) the constructor may store an unboxed version of a strict field.
478
479 Here's an example illustrating both:
480         data Ord a => T a = MkT Int! a
481 Here
482         T :: Ord a => Int -> a -> T a
483 but the rep type is
484         Trep :: Int# -> a -> T a
485 Actually, the unboxed part isn't implemented yet!
486
487 Note [Bangs on data constructor arguments]
488 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
489 Consider
490   data T = MkT !Int {-# UNPACK #-} !Int Bool
491 Its dcArgBangs field records the *users* specifications, in this case
492     [HsBang False, HsBang True, HsNoBang]
493 See the declaration of HsBang in BasicTypes
494
495 The dcr_bangs field of the dcRep field records the *actual, decided*
496 representation of the data constructor.  Without -O this might be
497     [HsStrict, HsStrict, HsNoBang]
498 With -O it might be
499     [HsStrict, HsUnpack, HsNoBang]
500 With -funbox-small-strict-fields it might be
501     [HsUnpack, HsUnpack, HsNoBang]
502
503 For imported data types, the dcArgBangs field is just the same as the
504 dcr_bangs field; we don't know what the user originally said.
505
506
507 %************************************************************************
508 %*                                                                      *
509 \subsection{Instances}
510 %*                                                                      *
511 %************************************************************************
512
513 \begin{code}
514 instance Eq DataCon where
515     a == b = getUnique a == getUnique b
516     a /= b = getUnique a /= getUnique b
517
518 instance Ord DataCon where
519     a <= b = getUnique a <= getUnique b
520     a <  b = getUnique a <  getUnique b
521     a >= b = getUnique a >= getUnique b
522     a >  b = getUnique a > getUnique b
523     compare a b = getUnique a `compare` getUnique b
524
525 instance Uniquable DataCon where
526     getUnique = dcUnique
527
528 instance NamedThing DataCon where
529     getName = dcName
530
531 instance Outputable DataCon where
532     ppr con = ppr (dataConName con)
533
534 instance Data.Data DataCon where
535     -- don't traverse?
536     toConstr _   = abstractConstr "DataCon"
537     gunfold _ _  = error "gunfold"
538     dataTypeOf _ = mkNoRepType "DataCon"
539
540 instance Outputable HsBang where
541     ppr HsNoBang             = empty
542     ppr (HsBang True)        = ptext (sLit "{-# UNPACK #-} !")
543     ppr (HsBang False)       = char '!'
544     ppr (HsUnpack Nothing)   = ptext (sLit "Unpk")
545     ppr (HsUnpack (Just co)) = ptext (sLit "Unpk") <> parens (ppr co)
546     ppr HsStrict             = ptext (sLit "SrictNotUnpacked")
547
548 instance Outputable StrictnessMark where
549   ppr MarkedStrict     = ptext (sLit "!")
550   ppr NotMarkedStrict  = empty
551
552
553 eqHsBang :: HsBang -> HsBang -> Bool
554 eqHsBang HsNoBang             HsNoBang             = True
555 eqHsBang HsStrict             HsStrict             = True
556 eqHsBang (HsBang b1)          (HsBang b2)          = b1 == b2
557 eqHsBang (HsUnpack Nothing)   (HsUnpack Nothing)   = True
558 eqHsBang (HsUnpack (Just c1)) (HsUnpack (Just c2)) = eqType (coercionType c1) (coercionType c2)
559 eqHsBang _ _ = False
560
561 isBanged :: HsBang -> Bool
562 isBanged HsNoBang = False
563 isBanged _        = True
564
565 isMarkedStrict :: StrictnessMark -> Bool
566 isMarkedStrict NotMarkedStrict = False
567 isMarkedStrict _               = True   -- All others are strict
568 \end{code}
569
570
571 %************************************************************************
572 %*                                                                      *
573 \subsection{Construction}
574 %*                                                                      *
575 %************************************************************************
576
577 \begin{code}
578 -- | Build a new data constructor
579 mkDataCon :: Name 
580           -> Bool               -- ^ Is the constructor declared infix?
581           -> [HsBang]           -- ^ Strictness annotations written in the source file
582           -> [FieldLabel]       -- ^ Field labels for the constructor, if it is a record, 
583                                 --   otherwise empty
584           -> [TyVar]            -- ^ Universally quantified type variables
585           -> [TyVar]            -- ^ Existentially quantified type variables
586           -> [(TyVar,Type)]     -- ^ GADT equalities
587           -> ThetaType          -- ^ Theta-type occuring before the arguments proper
588           -> [Type]             -- ^ Original argument types
589           -> Type               -- ^ Original result type
590           -> TyCon              -- ^ Representation type constructor
591           -> ThetaType          -- ^ The "stupid theta", context of the data declaration 
592                                 --   e.g. @data Eq a => T a ...@
593           -> Id                 -- ^ Worker Id
594           -> DataConRep         -- ^ Representation
595           -> DataCon
596   -- Can get the tag from the TyCon
597
598 mkDataCon name declared_infix
599           arg_stricts   -- Must match orig_arg_tys 1-1
600           fields
601           univ_tvs ex_tvs 
602           eq_spec theta
603           orig_arg_tys orig_res_ty rep_tycon
604           stupid_theta work_id rep
605 -- Warning: mkDataCon is not a good place to check invariants. 
606 -- If the programmer writes the wrong result type in the decl, thus:
607 --      data T a where { MkT :: S }
608 -- then it's possible that the univ_tvs may hit an assertion failure
609 -- if you pull on univ_tvs.  This case is checked by checkValidDataCon,
610 -- so the error is detected properly... it's just that asaertions here
611 -- are a little dodgy.
612
613   = con
614   where
615     is_vanilla = null ex_tvs && null eq_spec && null theta
616     con = MkData {dcName = name, dcUnique = nameUnique name, 
617                   dcVanilla = is_vanilla, dcInfix = declared_infix,
618                   dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, 
619                   dcEqSpec = eq_spec, 
620                   dcOtherTheta = theta,
621                   dcStupidTheta = stupid_theta, 
622                   dcOrigArgTys = orig_arg_tys, dcOrigResTy = orig_res_ty,
623                   dcRepTyCon = rep_tycon, 
624                   dcArgBangs = arg_stricts, 
625                   dcFields = fields, dcTag = tag, dcRepType = rep_ty,
626                   dcWorkId = work_id,
627                   dcRep = rep, 
628                   dcSourceArity = length orig_arg_tys,
629                   dcRepArity = length rep_arg_tys,
630                   dcPromoted = mb_promoted }
631
632         -- 
633         -- The 'arg_stricts' passed to mkDataCon are simply those for the
634         -- source-language arguments.  We add extra ones for the
635         -- dictionary arguments right here.
636
637     tag = assoc "mkDataCon" (tyConDataCons rep_tycon `zip` [fIRST_TAG..]) con
638     rep_arg_tys = dataConRepArgTys con
639     rep_ty = mkForAllTys univ_tvs $ mkForAllTys ex_tvs $ 
640              mkFunTys rep_arg_tys $
641              mkTyConApp rep_tycon (mkTyVarTys univ_tvs)
642
643     mb_promoted   -- See Note [Promoted data constructors] in TyCon
644       | all (isLiftedTypeKind . tyVarKind) (univ_tvs ++ ex_tvs)
645                           -- No kind polymorphism, and all of kind *
646       , null eq_spec   -- No constraints
647       , null theta
648       , all isPromotableType orig_arg_tys
649       = Just (mkPromotedDataCon con name (getUnique name) prom_kind arity)
650       | otherwise 
651       = Nothing          
652     prom_kind = promoteType (dataConUserType con)
653     arity     = dataConSourceArity con
654
655 eqSpecPreds :: [(TyVar,Type)] -> ThetaType
656 eqSpecPreds spec = [ mkEqPred (mkTyVarTy tv) ty | (tv,ty) <- spec ]
657 \end{code}
658
659 Note [Unpack equality predicates]
660 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
661 If we have a GADT with a contructor C :: (a~[b]) => b -> T a
662 we definitely want that equality predicate *unboxed* so that it
663 takes no space at all.  This is easily done: just give it
664 an UNPACK pragma. The rest of the unpack/repack code does the
665 heavy lifting.  This one line makes every GADT take a word less
666 space for each equality predicate, so it's pretty important!
667
668 \begin{code}
669 -- | The 'Name' of the 'DataCon', giving it a unique, rooted identification
670 dataConName :: DataCon -> Name
671 dataConName = dcName
672
673 -- | The tag used for ordering 'DataCon's
674 dataConTag :: DataCon -> ConTag
675 dataConTag  = dcTag
676
677 -- | The type constructor that we are building via this data constructor
678 dataConTyCon :: DataCon -> TyCon
679 dataConTyCon = dcRepTyCon
680
681 -- | The original type constructor used in the definition of this data
682 -- constructor.  In case of a data family instance, that will be the family
683 -- type constructor.
684 dataConOrigTyCon :: DataCon -> TyCon
685 dataConOrigTyCon dc 
686   | Just (tc, _) <- tyConFamInst_maybe (dcRepTyCon dc) = tc
687   | otherwise                                          = dcRepTyCon dc
688
689 -- | The representation type of the data constructor, i.e. the sort
690 -- type that will represent values of this type at runtime
691 dataConRepType :: DataCon -> Type
692 dataConRepType = dcRepType
693
694 -- | Should the 'DataCon' be presented infix?
695 dataConIsInfix :: DataCon -> Bool
696 dataConIsInfix = dcInfix
697
698 -- | The universally-quantified type variables of the constructor
699 dataConUnivTyVars :: DataCon -> [TyVar]
700 dataConUnivTyVars = dcUnivTyVars
701
702 -- | The existentially-quantified type variables of the constructor
703 dataConExTyVars :: DataCon -> [TyVar]
704 dataConExTyVars = dcExTyVars
705
706 -- | Both the universal and existentiatial type variables of the constructor
707 dataConAllTyVars :: DataCon -> [TyVar]
708 dataConAllTyVars (MkData { dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs })
709   = univ_tvs ++ ex_tvs
710
711 -- | Equalities derived from the result type of the data constructor, as written
712 -- by the programmer in any GADT declaration
713 dataConEqSpec :: DataCon -> [(TyVar,Type)]
714 dataConEqSpec = dcEqSpec
715
716 -- | The *full* constraints on the constructor type
717 dataConTheta :: DataCon -> ThetaType
718 dataConTheta (MkData { dcEqSpec = eq_spec, dcOtherTheta = theta }) 
719   = eqSpecPreds eq_spec ++ theta
720
721 -- | Get the Id of the 'DataCon' worker: a function that is the "actual"
722 -- constructor and has no top level binding in the program. The type may
723 -- be different from the obvious one written in the source program. Panics
724 -- if there is no such 'Id' for this 'DataCon'
725 dataConWorkId :: DataCon -> Id
726 dataConWorkId dc = dcWorkId dc
727
728 -- | Get the Id of the 'DataCon' wrapper: a function that wraps the "actual"
729 -- constructor so it has the type visible in the source program: c.f. 'dataConWorkId'.
730 -- Returns Nothing if there is no wrapper, which occurs for an algebraic data constructor 
731 -- and also for a newtype (whose constructor is inlined compulsorily)
732 dataConWrapId_maybe :: DataCon -> Maybe Id
733 dataConWrapId_maybe dc = case dcRep dc of
734                            NoDataConRep -> Nothing
735                            DCR { dcr_wrap_id = wrap_id } -> Just wrap_id
736
737 -- | Returns an Id which looks like the Haskell-source constructor by using
738 -- the wrapper if it exists (see 'dataConWrapId_maybe') and failing over to
739 -- the worker (see 'dataConWorkId')
740 dataConWrapId :: DataCon -> Id
741 dataConWrapId dc = case dcRep dc of
742                      NoDataConRep-> dcWorkId dc    -- worker=wrapper
743                      DCR { dcr_wrap_id = wrap_id } -> wrap_id
744
745 -- | Find all the 'Id's implicitly brought into scope by the data constructor. Currently,
746 -- the union of the 'dataConWorkId' and the 'dataConWrapId'
747 dataConImplicitIds :: DataCon -> [Id]
748 dataConImplicitIds (MkData { dcWorkId = work, dcRep = rep})
749   = case rep of
750        NoDataConRep               -> [work]
751        DCR { dcr_wrap_id = wrap } -> [wrap,work]
752
753 -- | The labels for the fields of this particular 'DataCon'
754 dataConFieldLabels :: DataCon -> [FieldLabel]
755 dataConFieldLabels = dcFields
756
757 -- | Extract the type for any given labelled field of the 'DataCon'
758 dataConFieldType :: DataCon -> FieldLabel -> Type
759 dataConFieldType con label
760   = case lookup label (dcFields con `zip` dcOrigArgTys con) of
761       Just ty -> ty
762       Nothing -> pprPanic "dataConFieldType" (ppr con <+> ppr label)
763
764 -- | The strictness markings decided on by the compiler.  Does not include those for
765 -- existential dictionaries.  The list is in one-to-one correspondence with the arity of the 'DataCon'
766 dataConStrictMarks :: DataCon -> [HsBang]
767 dataConStrictMarks = dcArgBangs
768
769 -- | Source-level arity of the data constructor
770 dataConSourceArity :: DataCon -> Arity
771 dataConSourceArity (MkData { dcSourceArity = arity }) = arity
772
773 -- | Gives the number of actual fields in the /representation/ of the 
774 -- data constructor. This may be more than appear in the source code;
775 -- the extra ones are the existentially quantified dictionaries
776 dataConRepArity :: DataCon -> Arity
777 dataConRepArity (MkData { dcRepArity = arity }) = arity
778
779
780 -- | The number of fields in the /representation/ of the constructor
781 -- AFTER taking into account the unpacking of any unboxed tuple fields
782 dataConRepRepArity :: DataCon -> RepArity
783 dataConRepRepArity dc = typeRepArity (dataConRepArity dc) (dataConRepType dc)
784
785 -- | Return whether there are any argument types for this 'DataCon's original source type
786 isNullarySrcDataCon :: DataCon -> Bool
787 isNullarySrcDataCon dc = null (dcOrigArgTys dc)
788
789 -- | Return whether there are any argument types for this 'DataCon's runtime representation type
790 isNullaryRepDataCon :: DataCon -> Bool
791 isNullaryRepDataCon dc = dataConRepArity dc == 0
792
793 dataConRepStrictness :: DataCon -> [StrictnessMark]
794 -- ^ Give the demands on the arguments of a
795 -- Core constructor application (Con dc args)
796 dataConRepStrictness dc = case dcRep dc of
797                             NoDataConRep -> [NotMarkedStrict | _ <- dataConRepArgTys dc]
798                             DCR { dcr_stricts = strs } -> strs
799
800 dataConRepBangs :: DataCon -> [HsBang]
801 dataConRepBangs dc = case dcRep dc of
802                        NoDataConRep -> dcArgBangs dc
803                        DCR { dcr_bangs = bangs } -> bangs
804
805 dataConBoxer :: DataCon -> Maybe DataConBoxer
806 dataConBoxer (MkData { dcRep = DCR { dcr_boxer = boxer } }) = Just boxer
807 dataConBoxer _ = Nothing 
808
809 -- | The \"signature\" of the 'DataCon' returns, in order:
810 --
811 -- 1) The result of 'dataConAllTyVars',
812 --
813 -- 2) All the 'ThetaType's relating to the 'DataCon' (coercion, dictionary, implicit
814 --    parameter - whatever)
815 --
816 -- 3) The type arguments to the constructor
817 --
818 -- 4) The /original/ result type of the 'DataCon'
819 dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
820 dataConSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, 
821                     dcEqSpec = eq_spec, dcOtherTheta  = theta, 
822                     dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
823   = (univ_tvs ++ ex_tvs, eqSpecPreds eq_spec ++ theta, arg_tys, res_ty)
824
825 -- | The \"full signature\" of the 'DataCon' returns, in order:
826 --
827 -- 1) The result of 'dataConUnivTyVars'
828 --
829 -- 2) The result of 'dataConExTyVars'
830 --
831 -- 3) The result of 'dataConEqSpec'
832 --
833 -- 4) The result of 'dataConDictTheta'
834 --
835 -- 5) The original argument types to the 'DataCon' (i.e. before 
836 --    any change of the representation of the type)
837 --
838 -- 6) The original result type of the 'DataCon'
839 dataConFullSig :: DataCon 
840                -> ([TyVar], [TyVar], [(TyVar,Type)], ThetaType, [Type], Type)
841 dataConFullSig (MkData {dcUnivTyVars = univ_tvs, dcExTyVars = ex_tvs, 
842                         dcEqSpec = eq_spec, dcOtherTheta = theta,
843                         dcOrigArgTys = arg_tys, dcOrigResTy = res_ty})
844   = (univ_tvs, ex_tvs, eq_spec, theta, arg_tys, res_ty)
845
846 dataConOrigResTy :: DataCon -> Type
847 dataConOrigResTy dc = dcOrigResTy dc
848
849 -- | The \"stupid theta\" of the 'DataCon', such as @data Eq a@ in:
850 --
851 -- > data Eq a => T a = ...
852 dataConStupidTheta :: DataCon -> ThetaType
853 dataConStupidTheta dc = dcStupidTheta dc
854
855 dataConUserType :: DataCon -> Type
856 -- ^ The user-declared type of the data constructor
857 -- in the nice-to-read form:
858 --
859 -- > T :: forall a b. a -> b -> T [a]
860 --
861 -- rather than:
862 --
863 -- > T :: forall a c. forall b. (c~[a]) => a -> b -> T c
864 --
865 -- NB: If the constructor is part of a data instance, the result type
866 -- mentions the family tycon, not the internal one.
867 dataConUserType  (MkData { dcUnivTyVars = univ_tvs, 
868                            dcExTyVars = ex_tvs, dcEqSpec = eq_spec,
869                            dcOtherTheta = theta, dcOrigArgTys = arg_tys,
870                            dcOrigResTy = res_ty })
871   = mkForAllTys ((univ_tvs `minusList` map fst eq_spec) ++ ex_tvs) $
872     mkFunTys theta $
873     mkFunTys arg_tys $
874     res_ty
875
876 -- | Finds the instantiated types of the arguments required to construct a 'DataCon' representation
877 -- NB: these INCLUDE any dictionary args
878 --     but EXCLUDE the data-declaration context, which is discarded
879 -- It's all post-flattening etc; this is a representation type
880 dataConInstArgTys :: DataCon    -- ^ A datacon with no existentials or equality constraints
881                                 -- However, it can have a dcTheta (notably it can be a 
882                                 -- class dictionary, with superclasses)
883                   -> [Type]     -- ^ Instantiated at these types
884                   -> [Type]
885 dataConInstArgTys dc@(MkData {dcUnivTyVars = univ_tvs, dcEqSpec = eq_spec,
886                               dcExTyVars = ex_tvs}) inst_tys
887  = ASSERT2 ( length univ_tvs == length inst_tys 
888            , ptext (sLit "dataConInstArgTys") <+> ppr dc $$ ppr univ_tvs $$ ppr inst_tys)
889    ASSERT2 ( null ex_tvs && null eq_spec, ppr dc )        
890    map (substTyWith univ_tvs inst_tys) (dataConRepArgTys dc)
891
892 -- | Returns just the instantiated /value/ argument types of a 'DataCon',
893 -- (excluding dictionary args)
894 dataConInstOrigArgTys 
895         :: DataCon      -- Works for any DataCon
896         -> [Type]       -- Includes existential tyvar args, but NOT
897                         -- equality constraints or dicts
898         -> [Type]
899 -- For vanilla datacons, it's all quite straightforward
900 -- But for the call in MatchCon, we really do want just the value args
901 dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,
902                                   dcUnivTyVars = univ_tvs, 
903                                   dcExTyVars = ex_tvs}) inst_tys
904   = ASSERT2( length tyvars == length inst_tys
905           , ptext (sLit "dataConInstOrigArgTys") <+> ppr dc $$ ppr tyvars $$ ppr inst_tys )
906     map (substTyWith tyvars inst_tys) arg_tys
907   where
908     tyvars = univ_tvs ++ ex_tvs
909 \end{code}
910
911 \begin{code}
912 -- | Returns the argument types of the wrapper, excluding all dictionary arguments
913 -- and without substituting for any type variables
914 dataConOrigArgTys :: DataCon -> [Type]
915 dataConOrigArgTys dc = dcOrigArgTys dc
916
917 -- | Returns the arg types of the worker, including *all* evidence, after any 
918 -- flattening has been done and without substituting for any type variables
919 dataConRepArgTys :: DataCon -> [Type]
920 dataConRepArgTys (MkData { dcRep = rep 
921                          , dcEqSpec = eq_spec
922                          , dcOtherTheta = theta
923                          , dcOrigArgTys = orig_arg_tys })
924   = case rep of
925       NoDataConRep -> ASSERT( null eq_spec ) theta ++ orig_arg_tys
926       DCR { dcr_arg_tys = arg_tys } -> arg_tys
927 \end{code}
928
929 \begin{code}
930 -- | The string @package:module.name@ identifying a constructor, which is attached
931 -- to its info table and used by the GHCi debugger and the heap profiler
932 dataConIdentity :: DataCon -> [Word8]
933 -- We want this string to be UTF-8, so we get the bytes directly from the FastStrings.
934 dataConIdentity dc = bytesFS (packageIdFS (modulePackageId mod)) ++ 
935                   fromIntegral (ord ':') : bytesFS (moduleNameFS (moduleName mod)) ++
936                   fromIntegral (ord '.') : bytesFS (occNameFS (nameOccName name))
937   where name = dataConName dc
938         mod  = ASSERT( isExternalName name ) nameModule name
939 \end{code}
940
941 \begin{code}
942 isTupleDataCon :: DataCon -> Bool
943 isTupleDataCon (MkData {dcRepTyCon = tc}) = isTupleTyCon tc
944         
945 isUnboxedTupleCon :: DataCon -> Bool
946 isUnboxedTupleCon (MkData {dcRepTyCon = tc}) = isUnboxedTupleTyCon tc
947
948 -- | Vanilla 'DataCon's are those that are nice boring Haskell 98 constructors
949 isVanillaDataCon :: DataCon -> Bool
950 isVanillaDataCon dc = dcVanilla dc
951 \end{code}
952
953 \begin{code}
954 classDataCon :: Class -> DataCon
955 classDataCon clas = case tyConDataCons (classTyCon clas) of
956                       (dict_constr:no_more) -> ASSERT( null no_more ) dict_constr 
957                       [] -> panic "classDataCon"
958 \end{code}
959
960 \begin{code}
961 dataConCannotMatch :: [Type] -> DataCon -> Bool
962 -- Returns True iff the data con *definitely cannot* match a 
963 --                  scrutinee of type (T tys)
964 --                  where T is the dcRepTyCon for the data con
965 -- NB: look at *all* equality constraints, not only those
966 --     in dataConEqSpec; see Trac #5168
967 dataConCannotMatch tys con
968   | null theta        = False   -- Common
969   | all isTyVarTy tys = False   -- Also common
970   | otherwise
971   = typesCantMatch [(Type.substTy subst ty1, Type.substTy subst ty2)
972                    | (ty1, ty2) <- concatMap predEqs theta ]
973   where
974     dc_tvs  = dataConUnivTyVars con
975     theta   = dataConTheta con
976     subst   = ASSERT2( length dc_tvs == length tys, ppr con $$ ppr dc_tvs $$ ppr tys ) 
977               zipTopTvSubst dc_tvs tys
978
979     -- TODO: could gather equalities from superclasses too
980     predEqs pred = case classifyPredType pred of
981                      EqPred ty1 ty2 -> [(ty1, ty2)]
982                      TuplePred ts   -> concatMap predEqs ts
983                      _              -> []
984 \end{code}
985
986 %************************************************************************
987 %*                                                                      *
988 \subsection{Splitting products}
989 %*                                                                      *
990 %************************************************************************
991
992 \begin{code}
993 -- | Extract the type constructor, type argument, data constructor and it's
994 -- /representation/ argument types from a type if it is a product type.
995 --
996 -- Precisely, we return @Just@ for any type that is all of:
997 --
998 --  * Concrete (i.e. constructors visible)
999 --
1000 --  * Single-constructor
1001 --
1002 --  * Not existentially quantified
1003 --
1004 -- Whether the type is a @data@ type or a @newtype@
1005 splitProductType_maybe
1006         :: Type                         -- ^ A product type, perhaps
1007         -> Maybe (TyCon,                -- The type constructor
1008                   [Type],               -- Type args of the tycon
1009                   DataCon,              -- The data constructor
1010                   [Type])               -- Its /representation/ arg types
1011
1012         -- Rejecing existentials is conservative.  Maybe some things
1013         -- could be made to work with them, but I'm not going to sweat
1014         -- it through till someone finds it's important.
1015
1016 splitProductType_maybe ty
1017   = case splitTyConApp_maybe ty of
1018         Just (tycon,ty_args)
1019            | isProductTyCon tycon       -- Includes check for non-existential,
1020                                         -- and for constructors visible
1021            -> Just (tycon, ty_args, data_con, dataConInstArgTys data_con ty_args)
1022            where
1023               data_con = ASSERT( not (null (tyConDataCons tycon)) ) 
1024                          head (tyConDataCons tycon)
1025         _other -> Nothing
1026
1027 -- | As 'splitProductType_maybe', but panics if the 'Type' is not a product type
1028 splitProductType :: String -> Type -> (TyCon, [Type], DataCon, [Type])
1029 splitProductType str ty
1030   = case splitProductType_maybe ty of
1031         Just stuff -> stuff
1032         Nothing    -> pprPanic (str ++ ": not a product") (pprType ty)
1033 \end{code}
1034
1035
1036 %************************************************************************
1037 %*                                                                      *
1038         Promoting of data types to the kind level
1039 %*                                                                      *
1040 %************************************************************************
1041
1042 These two 'promoted..' functions are here because
1043  * They belong together
1044  * 'promoteTyCon'  is used by promoteType
1045  * 'prmoteDataCon' depends on DataCon stuff
1046
1047 \begin{code}
1048 promoteDataCon :: DataCon -> TyCon
1049 promoteDataCon (MkData { dcPromoted = Just tc }) = tc
1050 promoteDataCon dc = pprPanic "promoteDataCon" (ppr dc)
1051
1052 promoteDataCon_maybe :: DataCon -> Maybe TyCon
1053 promoteDataCon_maybe (MkData { dcPromoted = mb_tc }) = mb_tc
1054
1055 promoteTyCon :: TyCon -> TyCon
1056 promoteTyCon tc
1057   = mkPromotedTyCon tc (promoteKind (tyConKind tc))
1058 \end{code}
1059
1060 Note [Promoting a Type to a Kind]
1061 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1062 Suppsoe we have a data constructor D
1063      D :: forall (a:*). Maybe a -> T a
1064 We promote this to be a type constructor 'D:
1065      'D :: forall (k:BOX). 'Maybe k -> 'T k
1066
1067 The transformation from type to kind is done by promoteType
1068
1069   * Convert forall (a:*) to forall (k:BOX), and substitute
1070
1071   * Ensure all foralls are at the top (no higher rank stuff)
1072
1073   * Ensure that all type constructors mentioned (Maybe and T
1074     in the example) are promotable; that is, they have kind 
1075           * -> ... -> * -> *
1076
1077 \begin{code}
1078 isPromotableType :: Type -> Bool
1079 isPromotableType (TyConApp tc tys) 
1080   | Just n <- isPromotableTyCon tc = tys `lengthIs` n && all isPromotableType tys
1081 isPromotableType (FunTy arg res)   = isPromotableType arg && isPromotableType res
1082 isPromotableType (TyVarTy {})      = True
1083 isPromotableType _                 = False
1084
1085 -- If tc's kind is [ *^n -> * ] returns [ Just n ], else returns [ Nothing ]
1086 isPromotableTyCon :: TyCon -> Maybe Int
1087 isPromotableTyCon tc
1088   | isDataTyCon tc || isNewTyCon tc
1089        -- Only *data* and *newtype* types can be promoted, 
1090        -- not synonyms, not type/data families
1091   , all isLiftedTypeKind (res:args) = Just $ length args
1092   | otherwise                       = Nothing
1093   where
1094     (args, res) = splitKindFunTys (tyConKind tc)
1095
1096 -- | Promotes a type to a kind. 
1097 -- Assumes the argument satisfies 'isPromotableType'
1098 promoteType :: Type -> Kind
1099 promoteType ty
1100   = mkForAllTys kvs (go rho)
1101   where
1102     (tvs, rho) = splitForAllTys ty
1103     kvs = [ mkKindVar (tyVarName tv) superKind | tv <- tvs ]
1104     env = zipVarEnv tvs kvs
1105
1106     go (TyConApp tc tys) = mkTyConApp (promoteTyCon tc) (map go tys)
1107     go (FunTy arg res)   = mkArrowKind (go arg) (go res)
1108     go (TyVarTy tv)      | Just kv <- lookupVarEnv env tv 
1109                          = TyVarTy kv
1110     go _ = panic "promoteType"  -- Argument did not satisfy isPromotableType
1111
1112 promoteKind :: Kind -> SuperKind
1113 -- Promote the kind of a type constructor
1114 -- from (* -> * -> *) to (BOX -> BOX -> BOX) 
1115 promoteKind (TyConApp tc []) 
1116   | tc `hasKey` liftedTypeKindTyConKey = superKind
1117 promoteKind (FunTy arg res) = FunTy (promoteKind arg) (promoteKind res)
1118 promoteKind k = pprPanic "promoteKind" (ppr k)
1119 \end{code}