X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FdeSugar%2FDsMeta.hs;h=9287bf58ddd9a8a6b677cff074aa8278c939bc5d;hb=c883ba41a1fd55f108b7b23223355a8f5d6d944a;hp=8571e1efb7c8fd441f4cc2897a6dc6c110b238a1;hpb=aadb64aa5644f2a3ad8a645e2c7a1e72c2f61e53;p=ghc-hetmet.git diff --git a/ghc/compiler/deSugar/DsMeta.hs b/ghc/compiler/deSugar/DsMeta.hs index 8571e1e..9287bf5 100644 --- a/ghc/compiler/deSugar/DsMeta.hs +++ b/ghc/compiler/deSugar/DsMeta.hs @@ -11,9 +11,10 @@ ----------------------------------------------------------------------------- -module DsMeta( dsBracket, +module DsMeta( dsBracket, dsReify, templateHaskellNames, qTyConName, - liftName, exprTyConName, declTyConName ) where + liftName, exprTyConName, declTyConName, + decTyConName, typTyConName ) where #include "HsVersions.h" @@ -30,23 +31,34 @@ import HsSyn ( Pat(..), HsExpr(..), Stmt(..), HsLit(..), HsOverLit(..), HsStmtContext(ListComp,DoExpr), ArithSeqInfo(..), HsBinds(..), MonoBinds(..), HsConDetails(..), TyClDecl(..), HsGroup(..), + HsReify(..), ReifyFlavour(..), HsType(..), HsContext(..), HsPred(..), HsTyOp(..), HsTyVarBndr(..), Sig(..), ForeignDecl(..), InstDecl(..), ConDecl(..), BangType(..), PendingSplice, splitHsInstDeclTy, placeHolderType, tyClDeclNames, collectHsBinders, collectPatBinders, collectPatsBinders, - hsTyVarName, hsConArgs, getBangType + hsTyVarName, hsConArgs, getBangType, + toHsType ) -import PrelNames ( mETA_META_Name, varQual, tcQual ) +import PrelNames ( mETA_META_Name ) +import MkIface ( ifaceTyThing ) import Name ( Name, nameOccName, nameModule ) import OccName ( isDataOcc, isTvOcc, occNameUserString ) -import Module ( moduleUserString ) -import Id ( Id ) +-- To avoid clashes with DsMeta.varName we must make a local alias for OccName.varName +-- we do this by removing varName from the import of OccName above, making +-- a qualified instance of OccName and using OccNameAlias.varName where varName +-- ws previously used in this file. +import qualified OccName( varName, tcName ) + +import Module ( Module, mkThPkgModule, moduleUserString ) +import Id ( Id, idType ) +import Name ( mkKnownKeyExternalName ) +import OccName ( mkOccFS ) import NameEnv import NameSet -import Type ( Type, mkGenTyConApp ) +import Type ( Type, TyThing(..), mkGenTyConApp ) import TyCon ( DataConDetails(..) ) import TysWiredIn ( stringTy ) import CoreSyn @@ -55,7 +67,7 @@ import SrcLoc ( noSrcLoc ) import Maybe ( catMaybes ) import Panic ( panic ) import Unique ( mkPreludeTyConUnique, mkPreludeMiscIdUnique ) -import BasicTypes ( NewOrData(..), StrictnessMark(..) ) +import BasicTypes ( NewOrData(..), StrictnessMark(..), isBoxed ) import Outputable import FastString ( mkFastString ) @@ -76,6 +88,30 @@ dsBracket brack splices do_brack (TypBr t) = do { MkC t1 <- repTy t ; return t1 } do_brack (DecBr ds) = do { MkC ds1 <- repTopDs ds ; return ds1 } +----------------------------------------------------------------------------- +dsReify :: HsReify Id -> DsM CoreExpr +-- Returns a CoreExpr of type reifyType --> M.Typ +-- reifyDecl --> M.Dec +-- reifyFixty --> M.Fix +dsReify (ReifyOut ReifyType name) + = do { thing <- dsLookupGlobal name ; + -- By deferring the lookup until now (rather than doing it + -- in the type checker) we ensure that all zonking has + -- been done. + case thing of + AnId id -> do { MkC e <- repTy (toHsType (idType id)) ; + return e } + other -> pprPanic "dsReify: reifyType" (ppr name) + } + +dsReify r@(ReifyOut ReifyDecl name) + = do { thing <- dsLookupGlobal name ; + mb_d <- repTyClD (ifaceTyThing thing) ; + case mb_d of + Just (MkC d) -> return d + Nothing -> pprPanic "dsReify" (ppr r) + } + {- -------------- Examples -------------------- [| \x -> x |] @@ -114,6 +150,7 @@ repTopDs group groupBinders (HsGroup { hs_valds = val_decls, hs_tyclds = tycl_decls, hs_fords = foreign_decls }) +-- Collect the binders of a Group = collectHsBinders val_decls ++ [n | d <- tycl_decls, (n,_) <- tyClDeclNames d] ++ [n | ForeignImport n _ _ _ _ <- foreign_decls] @@ -262,84 +299,105 @@ repTy (HsPredTy (HsClassP c tys)) = repTy (foldl HsAppTy (HsTyVar c) tys) repTy other_ty = pprPanic "repTy" (ppr other_ty) -- HsForAllTy, HsKindSig ------------------------------------------------------------------------------ +----------------------------------------------------------------------------- -- Expressions ------------------------------------------------------------------------------ +----------------------------------------------------------------------------- repEs :: [HsExpr Name] -> DsM (Core [M.Expr]) repEs es = do { es' <- mapM repE es ; coreList exprTyConName es' } +-- FIXME: some of these panics should be converted into proper error messages +-- unless we can make sure that constructs, which are plainly not +-- supported in TH already lead to error messages at an earlier stage repE :: HsExpr Name -> DsM (Core M.Expr) -repE (HsVar x) - = do { mb_val <- dsLookupMetaEnv x - ; case mb_val of - Nothing -> do { str <- globalVar x - ; repVarOrCon x str } - Just (Bound y) -> repVarOrCon x (coreVar y) - Just (Splice e) -> do { e' <- dsExpr e - ; return (MkC e') } } - -repE (HsIPVar x) = panic "Can't represent implicit parameters" -repE (HsLit l) = do { a <- repLiteral l; repLit a } -repE (HsOverLit l) = do { a <- repOverloadedLiteral l; repLit a } - -repE (HsSplice n e loc) - = do { mb_val <- dsLookupMetaEnv n - ; case mb_val of - Just (Splice e) -> do { e' <- dsExpr e - ; return (MkC e') } - other -> pprPanic "HsSplice" (ppr n) } - - -repE (HsLam m) = repLambda m -repE (HsApp x y) = do {a <- repE x; b <- repE y; repApp a b} -repE (NegApp x nm) = panic "No negate yet" -repE (SectionL x y) = do { a <- repE x; b <- repE y; repSectionL a b } -repE (SectionR x y) = do { a <- repE x; b <- repE y; repSectionR a b } - -repE (OpApp e1 (HsVar op) fix e2) - = do { arg1 <- repE e1; - arg2 <- repE e2; - the_op <- lookupOcc op ; - repInfixApp arg1 the_op arg2 } - -repE (HsCase e ms loc) - = do { arg <- repE e - ; ms2 <- mapM repMatchTup ms - ; repCaseE arg (nonEmptyCoreList ms2) } - --- I havn't got the types here right yet -repE (HsDo DoExpr sts _ ty loc) = do { (ss,zs) <- repSts sts; - e <- repDoE (nonEmptyCoreList zs); - wrapGenSyns expTyConName ss e } -repE (HsDo ListComp sts _ ty loc) = do { (ss,zs) <- repSts sts; - e <- repComp (nonEmptyCoreList zs); - wrapGenSyns expTyConName ss e } - -repE (ArithSeqIn (From e)) = do { ds1 <- repE e; repFrom ds1 } -repE (ArithSeqIn (FromThen e1 e2)) = do { ds1 <- repE e1; ds2 <- repE e2; - repFromThen ds1 ds2 } -repE (ArithSeqIn (FromTo e1 e2)) = do { ds1 <- repE e1; ds2 <- repE e2; - repFromTo ds1 ds2 } -repE (ArithSeqIn (FromThenTo e1 e2 e3)) = do { ds1 <- repE e1; ds2 <- repE e2; - ds3 <- repE e3; repFromThenTo ds1 ds2 ds3 } - -repE (HsIf x y z loc) = do { a <- repE x; b <- repE y; c <- repE z; repCond a b c } - -repE (HsLet bs e) = do { (ss,ds) <- repBinds bs - ; e2 <- addBinds ss (repE e) - ; z <- repLetE ds e2 - ; wrapGenSyns expTyConName ss z } -repE (ExplicitList ty es) = do { xs <- repEs es; repListExp xs } -repE (ExplicitTuple es boxed) = do { xs <- repEs es; repTup xs } - -repE (HsWith _ _ _) = panic "No with for implicit parameters yet" -repE (ExplicitPArr ty es) = panic "No parallel arrays yet" -repE (RecordConOut _ _ _) = panic "No record construction yet" -repE (RecordUpdOut _ _ _ _) = panic "No record update yet" -repE (ExprWithTySig e ty) = panic "No expressions with type signatures yet" - +repE (HsVar x) = + do { mb_val <- dsLookupMetaEnv x + ; case mb_val of + Nothing -> do { str <- globalVar x + ; repVarOrCon x str } + Just (Bound y) -> repVarOrCon x (coreVar y) + Just (Splice e) -> do { e' <- dsExpr e + ; return (MkC e') } } +repE (HsIPVar x) = + panic "DsMeta.repE: Can't represent implicit parameters" +repE (HsOverLit l) = do { a <- repOverloadedLiteral l; repLit a } +repE (HsLit l) = do { a <- repLiteral l; repLit a } +repE (HsLam m) = repLambda m +repE (HsApp x y) = do {a <- repE x; b <- repE y; repApp a b} +repE (OpApp e1 op fix e2) = + case op of + HsVar op -> do { arg1 <- repE e1; + arg2 <- repE e2; + the_op <- lookupOcc op ; + repInfixApp arg1 the_op arg2 } + _ -> panic "DsMeta.repE: Operator is not a variable" +repE (NegApp x nm) = panic "DsMeta.repE: No negate yet" +repE (HsPar x) = repE x +repE (SectionL x y) = do { a <- repE x; b <- repE y; repSectionL a b } +repE (SectionR x y) = do { a <- repE x; b <- repE y; repSectionR a b } +repE (HsCase e ms loc) = do { arg <- repE e + ; ms2 <- mapM repMatchTup ms + ; repCaseE arg (nonEmptyCoreList ms2) } +repE (HsIf x y z loc) = do + a <- repE x + b <- repE y + c <- repE z + repCond a b c +repE (HsLet bs e) = do { (ss,ds) <- repBinds bs + ; e2 <- addBinds ss (repE e) + ; z <- repLetE ds e2 + ; wrapGenSyns expTyConName ss z } +-- FIXME: I haven't got the types here right yet +repE (HsDo ctxt sts _ ty loc) + | isComprCtxt ctxt = do { (ss,zs) <- repSts sts; + e <- repDoE (nonEmptyCoreList zs); + wrapGenSyns expTyConName ss e } + | otherwise = + panic "DsMeta.repE: Can't represent mdo and [: :] yet" + where + isComprCtxt ListComp = True + isComprCtxt DoExpr = True + isComprCtxt _ = False +repE (ExplicitList ty es) = do { xs <- repEs es; repListExp xs } +repE (ExplicitPArr ty es) = + panic "DsMeta.repE: No explicit parallel arrays yet" +repE (ExplicitTuple es boxed) + | isBoxed boxed = do { xs <- repEs es; repTup xs } + | otherwise = panic "DsMeta.repE: Can't represent unboxed tuples" +repE (RecordConOut _ _ _) = panic "DsMeta.repE: No record construction yet" +repE (RecordUpdOut _ _ _ _) = panic "DsMeta.repE: No record update yet" +repE (ExprWithTySig e ty) = + panic "DsMeta.repE: No expressions with type signatures yet" +repE (ArithSeqOut _ aseq) = + case aseq of + From e -> do { ds1 <- repE e; repFrom ds1 } + FromThen e1 e2 -> do + ds1 <- repE e1 + ds2 <- repE e2 + repFromThen ds1 ds2 + FromTo e1 e2 -> do + ds1 <- repE e1 + ds2 <- repE e2 + repFromTo ds1 ds2 + FromThenTo e1 e2 e3 -> do + ds1 <- repE e1 + ds2 <- repE e2 + ds3 <- repE e3 + repFromThenTo ds1 ds2 ds3 +repE (PArrSeqOut _ aseq) = panic "DsMeta.repE: parallel array seq.s missing" +repE (HsCCall _ _ _ _ _) = panic "DsMeta.repE: Can't represent __ccall__" +repE (HsSCC _ _) = panic "DsMeta.repE: Can't represent SCC" +repE (HsBracketOut _ _) = + panic "DsMeta.repE: Can't represent Oxford brackets" +repE (HsSplice n e loc) = do { mb_val <- dsLookupMetaEnv n + ; case mb_val of + Just (Splice e) -> do { e' <- dsExpr e + ; return (MkC e') } + other -> pprPanic "HsSplice" (ppr n) } +repE (HsReify _) = panic "DsMeta.repE: Can't represent reification" +repE e = + pprPanic "DsMeta.repE: Illegal expression form" (ppr e) ----------------------------------------------------------------------------- -- Building representations of auxillary structures like Match, Clause, Stmt, @@ -451,6 +509,8 @@ rep_binds (MonoBind bs sigs _) = do { core1 <- rep_monobind bs ; core2 <- rep_sigs sigs ; return (core1 ++ core2) } +rep_binds (IPBinds _ _) + = panic "DsMeta:repBinds: can't do implicit parameters" rep_monobind :: MonoBinds Name -> DsM [Core M.Decl] rep_monobind EmptyMonoBinds = return [] @@ -929,91 +989,103 @@ templateHaskellNames constrName, exprTyConName, declTyConName, pattTyConName, mtchTyConName, clseTyConName, stmtTyConName, consTyConName, typeTyConName, - qTyConName, expTyConName, matTyConName, clsTyConName ] - - - -intLName = varQual mETA_META_Name FSLIT("intL") intLIdKey -charLName = varQual mETA_META_Name FSLIT("charL") charLIdKey -plitName = varQual mETA_META_Name FSLIT("plit") plitIdKey -pvarName = varQual mETA_META_Name FSLIT("pvar") pvarIdKey -ptupName = varQual mETA_META_Name FSLIT("ptup") ptupIdKey -pconName = varQual mETA_META_Name FSLIT("pcon") pconIdKey -ptildeName = varQual mETA_META_Name FSLIT("ptilde") ptildeIdKey -paspatName = varQual mETA_META_Name FSLIT("paspat") paspatIdKey -pwildName = varQual mETA_META_Name FSLIT("pwild") pwildIdKey -varName = varQual mETA_META_Name FSLIT("var") varIdKey -conName = varQual mETA_META_Name FSLIT("con") conIdKey -litName = varQual mETA_META_Name FSLIT("lit") litIdKey -appName = varQual mETA_META_Name FSLIT("app") appIdKey -infixEName = varQual mETA_META_Name FSLIT("infixE") infixEIdKey -lamName = varQual mETA_META_Name FSLIT("lam") lamIdKey -tupName = varQual mETA_META_Name FSLIT("tup") tupIdKey -doEName = varQual mETA_META_Name FSLIT("doE") doEIdKey -compName = varQual mETA_META_Name FSLIT("comp") compIdKey -listExpName = varQual mETA_META_Name FSLIT("listExp") listExpIdKey -condName = varQual mETA_META_Name FSLIT("cond") condIdKey -letEName = varQual mETA_META_Name FSLIT("letE") letEIdKey -caseEName = varQual mETA_META_Name FSLIT("caseE") caseEIdKey -infixAppName = varQual mETA_META_Name FSLIT("infixApp") infixAppIdKey -sectionLName = varQual mETA_META_Name FSLIT("sectionL") sectionLIdKey -sectionRName = varQual mETA_META_Name FSLIT("sectionR") sectionRIdKey -guardedName = varQual mETA_META_Name FSLIT("guarded") guardedIdKey -normalName = varQual mETA_META_Name FSLIT("normal") normalIdKey -bindStName = varQual mETA_META_Name FSLIT("bindSt") bindStIdKey -letStName = varQual mETA_META_Name FSLIT("letSt") letStIdKey -noBindStName = varQual mETA_META_Name FSLIT("noBindSt") noBindStIdKey -parStName = varQual mETA_META_Name FSLIT("parSt") parStIdKey -fromName = varQual mETA_META_Name FSLIT("from") fromIdKey -fromThenName = varQual mETA_META_Name FSLIT("fromThen") fromThenIdKey -fromToName = varQual mETA_META_Name FSLIT("fromTo") fromToIdKey -fromThenToName = varQual mETA_META_Name FSLIT("fromThenTo") fromThenToIdKey -liftName = varQual mETA_META_Name FSLIT("lift") liftIdKey -gensymName = varQual mETA_META_Name FSLIT("gensym") gensymIdKey -returnQName = varQual mETA_META_Name FSLIT("returnQ") returnQIdKey -bindQName = varQual mETA_META_Name FSLIT("bindQ") bindQIdKey + qTyConName, expTyConName, matTyConName, clsTyConName, + decTyConName, typTyConName ] + + +varQual = mk_known_key_name OccName.varName +tcQual = mk_known_key_name OccName.tcName + +thModule :: Module +-- NB: the THSyntax module comes from the "haskell-src" package +thModule = mkThPkgModule mETA_META_Name + +mk_known_key_name space str uniq + = mkKnownKeyExternalName thModule (mkOccFS space str) uniq + +intLName = varQual FSLIT("intL") intLIdKey +charLName = varQual FSLIT("charL") charLIdKey +plitName = varQual FSLIT("plit") plitIdKey +pvarName = varQual FSLIT("pvar") pvarIdKey +ptupName = varQual FSLIT("ptup") ptupIdKey +pconName = varQual FSLIT("pcon") pconIdKey +ptildeName = varQual FSLIT("ptilde") ptildeIdKey +paspatName = varQual FSLIT("paspat") paspatIdKey +pwildName = varQual FSLIT("pwild") pwildIdKey +varName = varQual FSLIT("var") varIdKey +conName = varQual FSLIT("con") conIdKey +litName = varQual FSLIT("lit") litIdKey +appName = varQual FSLIT("app") appIdKey +infixEName = varQual FSLIT("infixE") infixEIdKey +lamName = varQual FSLIT("lam") lamIdKey +tupName = varQual FSLIT("tup") tupIdKey +doEName = varQual FSLIT("doE") doEIdKey +compName = varQual FSLIT("comp") compIdKey +listExpName = varQual FSLIT("listExp") listExpIdKey +condName = varQual FSLIT("cond") condIdKey +letEName = varQual FSLIT("letE") letEIdKey +caseEName = varQual FSLIT("caseE") caseEIdKey +infixAppName = varQual FSLIT("infixApp") infixAppIdKey +sectionLName = varQual FSLIT("sectionL") sectionLIdKey +sectionRName = varQual FSLIT("sectionR") sectionRIdKey +guardedName = varQual FSLIT("guarded") guardedIdKey +normalName = varQual FSLIT("normal") normalIdKey +bindStName = varQual FSLIT("bindSt") bindStIdKey +letStName = varQual FSLIT("letSt") letStIdKey +noBindStName = varQual FSLIT("noBindSt") noBindStIdKey +parStName = varQual FSLIT("parSt") parStIdKey +fromName = varQual FSLIT("from") fromIdKey +fromThenName = varQual FSLIT("fromThen") fromThenIdKey +fromToName = varQual FSLIT("fromTo") fromToIdKey +fromThenToName = varQual FSLIT("fromThenTo") fromThenToIdKey +liftName = varQual FSLIT("lift") liftIdKey +gensymName = varQual FSLIT("gensym") gensymIdKey +returnQName = varQual FSLIT("returnQ") returnQIdKey +bindQName = varQual FSLIT("bindQ") bindQIdKey -- type Mat = ... -matchName = varQual mETA_META_Name FSLIT("match") matchIdKey - --- type Cls = ... -clauseName = varQual mETA_META_Name FSLIT("clause") clauseIdKey - --- data Dec = ... -funName = varQual mETA_META_Name FSLIT("fun") funIdKey -valName = varQual mETA_META_Name FSLIT("val") valIdKey -dataDName = varQual mETA_META_Name FSLIT("dataD") dataDIdKey -classDName = varQual mETA_META_Name FSLIT("classD") classDIdKey -instName = varQual mETA_META_Name FSLIT("inst") instIdKey -protoName = varQual mETA_META_Name FSLIT("proto") protoIdKey - --- data Typ = ... -tvarName = varQual mETA_META_Name FSLIT("tvar") tvarIdKey -tconName = varQual mETA_META_Name FSLIT("tcon") tconIdKey -tappName = varQual mETA_META_Name FSLIT("tapp") tappIdKey - --- data Tag = ... -arrowTyConName = varQual mETA_META_Name FSLIT("arrowTyCon") arrowIdKey -tupleTyConName = varQual mETA_META_Name FSLIT("tupleTyCon") tupleIdKey -listTyConName = varQual mETA_META_Name FSLIT("listTyCon") listIdKey -namedTyConName = varQual mETA_META_Name FSLIT("namedTyCon") namedTyConIdKey - --- data Con = ... -constrName = varQual mETA_META_Name FSLIT("constr") constrIdKey - -exprTyConName = tcQual mETA_META_Name FSLIT("Expr") exprTyConKey -declTyConName = tcQual mETA_META_Name FSLIT("Decl") declTyConKey -pattTyConName = tcQual mETA_META_Name FSLIT("Patt") pattTyConKey -mtchTyConName = tcQual mETA_META_Name FSLIT("Mtch") mtchTyConKey -clseTyConName = tcQual mETA_META_Name FSLIT("Clse") clseTyConKey -stmtTyConName = tcQual mETA_META_Name FSLIT("Stmt") stmtTyConKey -consTyConName = tcQual mETA_META_Name FSLIT("Cons") consTyConKey -typeTyConName = tcQual mETA_META_Name FSLIT("Type") typeTyConKey - -qTyConName = tcQual mETA_META_Name FSLIT("Q") qTyConKey -expTyConName = tcQual mETA_META_Name FSLIT("Exp") expTyConKey -matTyConName = tcQual mETA_META_Name FSLIT("Mat") matTyConKey -clsTyConName = tcQual mETA_META_Name FSLIT("Cls") clsTyConKey +matchName = varQual FSLIT("match") matchIdKey + +-- type Cls = ... +clauseName = varQual FSLIT("clause") clauseIdKey + +-- data Dec = ... +funName = varQual FSLIT("fun") funIdKey +valName = varQual FSLIT("val") valIdKey +dataDName = varQual FSLIT("dataD") dataDIdKey +classDName = varQual FSLIT("classD") classDIdKey +instName = varQual FSLIT("inst") instIdKey +protoName = varQual FSLIT("proto") protoIdKey + +-- data Typ = ... +tvarName = varQual FSLIT("tvar") tvarIdKey +tconName = varQual FSLIT("tcon") tconIdKey +tappName = varQual FSLIT("tapp") tappIdKey + +-- data Tag = ... +arrowTyConName = varQual FSLIT("arrowTyCon") arrowIdKey +tupleTyConName = varQual FSLIT("tupleTyCon") tupleIdKey +listTyConName = varQual FSLIT("listTyCon") listIdKey +namedTyConName = varQual FSLIT("namedTyCon") namedTyConIdKey + +-- data Con = ... +constrName = varQual FSLIT("constr") constrIdKey + +exprTyConName = tcQual FSLIT("Expr") exprTyConKey +declTyConName = tcQual FSLIT("Decl") declTyConKey +pattTyConName = tcQual FSLIT("Patt") pattTyConKey +mtchTyConName = tcQual FSLIT("Mtch") mtchTyConKey +clseTyConName = tcQual FSLIT("Clse") clseTyConKey +stmtTyConName = tcQual FSLIT("Stmt") stmtTyConKey +consTyConName = tcQual FSLIT("Cons") consTyConKey +typeTyConName = tcQual FSLIT("Type") typeTyConKey + +qTyConName = tcQual FSLIT("Q") qTyConKey +expTyConName = tcQual FSLIT("Exp") expTyConKey +decTyConName = tcQual FSLIT("Dec") decTyConKey +typTyConName = tcQual FSLIT("Typ") typTyConKey +matTyConName = tcQual FSLIT("Mat") matTyConKey +clsTyConName = tcQual FSLIT("Cls") clsTyConKey -- TyConUniques available: 100-119 -- Check in PrelNames if you want to change this @@ -1030,6 +1102,9 @@ clseTyConKey = mkPreludeTyConUnique 108 stmtTyConKey = mkPreludeTyConUnique 109 consTyConKey = mkPreludeTyConUnique 110 typeTyConKey = mkPreludeTyConUnique 111 +typTyConKey = mkPreludeTyConUnique 112 +decTyConKey = mkPreludeTyConUnique 113 + -- IdUniques available: 200-299