tcIfaceDecl :: Bool	-- True <=> discard IdInfo on IfaceId bindings
	    -> IfaceDecl
	    -> IfL TyThing
tcIfaceDecl = tc_iface_decl NoParentTyCon

tc_iface_decl :: TyConParent	-- For nested declarations
              -> Bool	-- True <=> discard IdInfo on IfaceId bindings
	      -> IfaceDecl
	      -> IfL TyThing
tc_iface_decl _ ignore_prags (IfaceId {ifName = occ_name, ifType = iface_type, 
 	                               ifIdDetails = details, ifIdInfo = info})
  = do	{ name <- lookupIfaceTop occ_name
	; ty <- tcIfaceType iface_type
	; details <- tcIdDetails ty details
	; info <- tcIdInfo ignore_prags name ty info
	; return (AnId (mkGlobalId details name ty info)) }

tc_iface_decl parent _ (IfaceData {ifName = occ_name, 
			  ifTyVars = tv_bndrs, 
			  ifCtxt = ctxt, ifGadtSyntax = gadt_syn,
			  ifCons = rdr_cons, 
			  ifRec = is_rec, 
			  ifGeneric = want_generic,
			  ifFamInst = mb_family })
  = bindIfaceTyVars_AT tv_bndrs $ \ tyvars -> do
    { tc_name <- lookupIfaceTop occ_name
    ; tycon <- fixM ( \ tycon -> do
	    { stupid_theta <- tcIfaceCtxt ctxt
	    ; cons <- tcIfaceDataCons tc_name tycon tyvars rdr_cons
	    ; mb_fam_inst  <- tcFamInst mb_family
	    ; buildAlgTyCon tc_name tyvars stupid_theta cons is_rec
			    want_generic gadt_syn parent mb_fam_inst
	    })
    ; traceIf (text "tcIfaceDecl4" <+> ppr tycon)
    ; return (ATyCon tycon) }

tc_iface_decl parent _ (IfaceSyn {ifName = occ_name, ifTyVars = tv_bndrs, 
		         	  ifSynRhs = mb_rhs_ty,
		         	  ifSynKind = kind, ifFamInst = mb_family})
   = bindIfaceTyVars_AT tv_bndrs $ \ tyvars -> do
     { tc_name  <- lookupIfaceTop occ_name
     ; rhs_kind <- tcIfaceType kind	-- Note [Synonym kind loop]
     ; rhs      <- forkM (mk_doc tc_name) $ 
       	      	   tc_syn_rhs mb_rhs_ty
     ; fam_info <- tcFamInst mb_family
     ; tycon <- buildSynTyCon tc_name tyvars rhs rhs_kind parent fam_info
     ; return (ATyCon tycon)
     }
   where
     mk_doc n = ptext (sLit "Type syonym") <+> ppr n
     tc_syn_rhs Nothing   = return SynFamilyTyCon
     tc_syn_rhs (Just ty) = do { rhs_ty <- tcIfaceType ty
		               ; return (SynonymTyCon rhs_ty) }

tc_iface_decl _parent ignore_prags
	    (IfaceClass {ifCtxt = rdr_ctxt, ifName = occ_name, 
			 ifTyVars = tv_bndrs, ifFDs = rdr_fds, 
			 ifATs = rdr_ats, ifSigs = rdr_sigs, 
			 ifRec = tc_isrec })
-- ToDo: in hs-boot files we should really treat abstract classes specially,
--	 as we do abstract tycons
  = bindIfaceTyVars tv_bndrs $ \ tyvars -> do
    { cls_name <- lookupIfaceTop occ_name
    ; ctxt <- tcIfaceCtxt rdr_ctxt
    ; sigs <- mapM tc_sig rdr_sigs
    ; fds  <- mapM tc_fd rdr_fds
    ; cls  <- fixM $ \ cls -> do
              { ats  <- mapM (tc_iface_decl (AssocFamilyTyCon cls) ignore_prags) rdr_ats
              ; buildClass ignore_prags cls_name tyvars ctxt fds ats sigs tc_isrec }
    ; return (AClass cls) }
  where
   tc_sig (IfaceClassOp occ dm rdr_ty)
     = do { op_name <- lookupIfaceTop occ
	  ; op_ty   <- forkM (mk_doc op_name rdr_ty) (tcIfaceType rdr_ty)
		-- Must be done lazily for just the same reason as the 
		-- type of a data con; to avoid sucking in types that
		-- it mentions unless it's necessray to do so
	  ; return (op_name, dm, op_ty) }

   mk_doc op_name op_ty = ptext (sLit "Class op") <+> sep [ppr op_name, ppr op_ty]

   tc_fd (tvs1, tvs2) = do { tvs1' <- mapM tcIfaceTyVar tvs1
			   ; tvs2' <- mapM tcIfaceTyVar tvs2
			   ; return (tvs1', tvs2') }

tc_iface_decl _ _ (IfaceForeign {ifName = rdr_name, ifExtName = ext_name})
  = do	{ name <- lookupIfaceTop rdr_name
	; return (ATyCon (mkForeignTyCon name ext_name 
					 liftedTypeKind 0)) }

tcFamInst :: Maybe (IfaceTyCon, [IfaceType]) -> IfL (Maybe (TyCon, [Type]))
tcFamInst Nothing           = return Nothing
tcFamInst (Just (fam, tys)) = do { famTyCon <- tcIfaceTyCon fam
      	    			 ; insttys <- mapM tcIfaceType tys
       	    			 ; return $ Just (famTyCon, insttys) }

tcIfaceDataCons :: Name -> TyCon -> [TyVar] -> IfaceConDecls -> IfL AlgTyConRhs
tcIfaceDataCons tycon_name tycon _ if_cons
  = case if_cons of
	IfAbstractTyCon	 -> return mkAbstractTyConRhs
	IfOpenDataTyCon	 -> return DataFamilyTyCon
	IfDataTyCon cons -> do 	{ data_cons <- mapM tc_con_decl cons
				; return (mkDataTyConRhs data_cons) }
	IfNewTyCon con	 -> do 	{ data_con <- tc_con_decl con
				; mkNewTyConRhs tycon_name tycon data_con }
  where
    tc_con_decl (IfCon { ifConInfix = is_infix, 
			 ifConUnivTvs = univ_tvs, ifConExTvs = ex_tvs,
			 ifConOcc = occ, ifConCtxt = ctxt, ifConEqSpec = spec,
			 ifConArgTys = args, ifConFields = field_lbls,
			 ifConStricts = stricts})
     = bindIfaceTyVars univ_tvs $ \ univ_tyvars -> do
       bindIfaceTyVars ex_tvs	 $ \ ex_tyvars -> do
	{ name  <- lookupIfaceTop occ
        ; eq_spec <- tcIfaceEqSpec spec
	; theta <- tcIfaceCtxt ctxt	-- Laziness seems not worth the bother here
	 	-- At one stage I thought that this context checking *had*
		-- to be lazy, because of possible mutual recursion between the
		-- type and the classe: 
		-- E.g. 
		--	class Real a where { toRat :: a -> Ratio Integer }
		--	data (Real a) => Ratio a = ...
		-- But now I think that the laziness in checking class ops breaks 
		-- the loop, so no laziness needed

	-- Read the argument types, but lazily to avoid faulting in
	-- the component types unless they are really needed
 	; arg_tys <- forkM (mk_doc name) (mapM tcIfaceType args)
	; lbl_names <- mapM lookupIfaceTop field_lbls

	-- Remember, tycon is the representation tycon
	; let orig_res_ty = mkFamilyTyConApp tycon 
				(substTyVars (mkTopTvSubst eq_spec) univ_tyvars)

	; buildDataCon name is_infix {- Not infix -}
		       stricts lbl_names
		       univ_tyvars ex_tyvars 
                       eq_spec theta 
		       arg_tys orig_res_ty tycon
	}
    mk_doc con_name = ptext (sLit "Constructor") <+> ppr con_name

tcIfaceEqSpec :: [(OccName, IfaceType)] -> IfL [(TyVar, Type)]
tcIfaceEqSpec spec
  = mapM do_item spec
  where
    do_item (occ, if_ty) = do { tv <- tcIfaceTyVar (occNameFS occ)
                              ; ty <- tcIfaceType if_ty
                              ; return (tv,ty) }

tcIfaceInst :: IfaceInst -> IfL Instance
tcIfaceInst (IfaceInst { ifDFun = dfun_occ, ifOFlag = oflag,
			 ifInstCls = cls, ifInstTys = mb_tcs })
  = do	{ dfun    <- forkM (ptext (sLit "Dict fun") <+> ppr dfun_occ) $
		     tcIfaceExtId dfun_occ
        ; let mb_tcs' = map (fmap ifaceTyConName) mb_tcs
	; return (mkImportedInstance cls mb_tcs' dfun oflag) }

tcIfaceFamInst :: IfaceFamInst -> IfL FamInst
tcIfaceFamInst (IfaceFamInst { ifFamInstTyCon = tycon, 
			       ifFamInstFam = fam, ifFamInstTys = mb_tcs })
--	{ tycon'  <- forkM (ptext (sLit "Inst tycon") <+> ppr tycon) $
-- the above line doesn't work, but this below does => CPP in Haskell = evil!
    = do tycon'  <- forkM (text ("Inst tycon") <+> ppr tycon) $
                    tcIfaceTyCon tycon
         let mb_tcs' = map (fmap ifaceTyConName) mb_tcs
         return (mkImportedFamInst fam mb_tcs' tycon')

tcIfaceRules :: Bool 		-- True <=> ignore rules
	     -> [IfaceRule]
	     -> IfL [CoreRule]
tcIfaceRules ignore_prags if_rules
  | ignore_prags = return []
  | otherwise    = mapM tcIfaceRule if_rules

tcIfaceRule :: IfaceRule -> IfL CoreRule
tcIfaceRule (IfaceRule {ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
			ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs,
                        ifRuleAuto = auto })
  = do	{ ~(bndrs', args', rhs') <- 
		-- Typecheck the payload lazily, in the hope it'll never be looked at
		forkM (ptext (sLit "Rule") <+> ftext name) $
		bindIfaceBndrs bndrs 			  $ \ bndrs' ->
		do { args' <- mapM tcIfaceExpr args
		   ; rhs'  <- tcIfaceExpr rhs
		   ; return (bndrs', args', rhs') }
	; let mb_tcs = map ifTopFreeName args
	; return (Rule { ru_name = name, ru_fn = fn, ru_act = act, 
			  ru_bndrs = bndrs', ru_args = args', 
			  ru_rhs = occurAnalyseExpr rhs', 
			  ru_rough = mb_tcs,
                          ru_auto = auto,
			  ru_local = False }) }	-- An imported RULE is never for a local Id
						-- or, even if it is (module loop, perhaps)
						-- we'll just leave it in the non-local set
  where
	-- This function *must* mirror exactly what Rules.topFreeName does
	-- We could have stored the ru_rough field in the iface file
	-- but that would be redundant, I think.
	-- The only wrinkle is that we must not be deceived by
	-- type syononyms at the top of a type arg.  Since
	-- we can't tell at this point, we are careful not
	-- to write them out in coreRuleToIfaceRule
    ifTopFreeName :: IfaceExpr -> Maybe Name
    ifTopFreeName (IfaceType (IfaceTyConApp tc _ )) = Just (ifaceTyConName tc)
    ifTopFreeName (IfaceApp f _)                    = ifTopFreeName f
    ifTopFreeName (IfaceExt n)                      = Just n
    ifTopFreeName _                                 = Nothing

tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
tcIfaceAnnotations = mapM tcIfaceAnnotation

tcIfaceAnnotation :: IfaceAnnotation -> IfL Annotation
tcIfaceAnnotation (IfaceAnnotation target serialized) = do
    target' <- tcIfaceAnnTarget target
    return $ Annotation {
        ann_target = target',
        ann_value = serialized
    }

tcIfaceAnnTarget :: IfaceAnnTarget -> IfL (AnnTarget Name)
tcIfaceAnnTarget (NamedTarget occ) = do
    name <- lookupIfaceTop occ
    return $ NamedTarget name
tcIfaceAnnTarget (ModuleTarget mod) = do
    return $ ModuleTarget mod

tcIfaceVectInfo :: Module -> TypeEnv  -> IfaceVectInfo -> IfL VectInfo
tcIfaceVectInfo mod typeEnv (IfaceVectInfo 
                             { ifaceVectInfoVar        = vars
                             , ifaceVectInfoTyCon      = tycons
                             , ifaceVectInfoTyConReuse = tyconsReuse
                             })
  = do { vVars     <- mapM vectVarMapping vars
       ; tyConRes1 <- mapM vectTyConMapping      tycons
       ; tyConRes2 <- mapM vectTyConReuseMapping tyconsReuse
       ; let (vTyCons, vDataCons, vPAs, vIsos) = unzip4 (tyConRes1 ++ tyConRes2)
       ; return $ VectInfo 
                  { vectInfoVar     = mkVarEnv  vVars
                  , vectInfoTyCon   = mkNameEnv vTyCons
                  , vectInfoDataCon = mkNameEnv (concat vDataCons)
                  , vectInfoPADFun  = mkNameEnv vPAs
                  , vectInfoIso     = mkNameEnv vIsos
                  }
       }
  where
    vectVarMapping name 
      = do { vName <- lookupOrig mod (mkVectOcc (nameOccName name))
           ; let { var  = lookupVar name
                 ; vVar = lookupVar vName
                 }
           ; return (var, (var, vVar))
           }
    vectTyConMapping name 
      = do { vName   <- lookupOrig mod (mkVectTyConOcc (nameOccName name))
           ; paName  <- lookupOrig mod (mkPADFunOcc    (nameOccName name))
           ; isoName <- lookupOrig mod (mkVectIsoOcc   (nameOccName name))
           ; let { tycon    = lookupTyCon name
                 ; vTycon   = lookupTyCon vName
                 ; paTycon  = lookupVar paName
                 ; isoTycon = lookupVar isoName
                 }
           ; vDataCons <- mapM vectDataConMapping (tyConDataCons tycon)
           ; return ((name, (tycon, vTycon)),    -- (T, T_v)
                     vDataCons,                  -- list of (Ci, Ci_v)
                     (vName, (vTycon, paTycon)), -- (T_v, paT)
                     (name, (tycon, isoTycon)))  -- (T, isoT)
           }
    vectTyConReuseMapping name 
      = do { paName  <- lookupOrig mod (mkPADFunOcc    (nameOccName name))
           ; isoName <- lookupOrig mod (mkVectIsoOcc   (nameOccName name))
           ; let { tycon      = lookupTyCon name
                 ; paTycon    = lookupVar paName
                 ; isoTycon   = lookupVar isoName
                 ; vDataCons  = [ (dataConName dc, (dc, dc)) 
                                | dc <- tyConDataCons tycon]
                 }
           ; return ((name, (tycon, tycon)),     -- (T, T)
                     vDataCons,                  -- list of (Ci, Ci)
                     (name, (tycon, paTycon)),   -- (T, paT)
                     (name, (tycon, isoTycon)))  -- (T, isoT)
           }
    vectDataConMapping datacon
      = do { let name = dataConName datacon
           ; vName <- lookupOrig mod (mkVectDataConOcc (nameOccName name))
           ; let vDataCon = lookupDataCon vName
           ; return (name, (datacon, vDataCon))
           }
    --
    lookupVar name = case lookupTypeEnv typeEnv name of
                       Just (AnId var) -> var
                       Just _         -> 
                         panic "TcIface.tcIfaceVectInfo: not an id"
                       Nothing        ->
                         panic "TcIface.tcIfaceVectInfo: unknown name"
    lookupTyCon name = case lookupTypeEnv typeEnv name of
                         Just (ATyCon tc) -> tc
                         Just _         -> 
                           panic "TcIface.tcIfaceVectInfo: not a tycon"
                         Nothing        ->
                           panic "TcIface.tcIfaceVectInfo: unknown name"
    lookupDataCon name = case lookupTypeEnv typeEnv name of
                           Just (ADataCon dc) -> dc
                           Just _         -> 
                             panic "TcIface.tcIfaceVectInfo: not a datacon"
                           Nothing        ->
                             panic "TcIface.tcIfaceVectInfo: unknown name"

tcIfaceType :: IfaceType -> IfL Type
tcIfaceType (IfaceTyVar n)        = do { tv <- tcIfaceTyVar n; return (TyVarTy tv) }
tcIfaceType (IfaceAppTy t1 t2)    = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (AppTy t1' t2') }
tcIfaceType (IfaceFunTy t1 t2)    = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (FunTy t1' t2') }
tcIfaceType (IfaceTyConApp tc ts) = do { tc' <- tcIfaceTyCon tc; ts' <- tcIfaceTypes ts; return (mkTyConApp tc' ts') }
tcIfaceType (IfaceForAllTy tv t)  = bindIfaceTyVar tv $ \ tv' -> do { t' <- tcIfaceType t; return (ForAllTy tv' t') }
tcIfaceType (IfacePredTy st)      = do { st' <- tcIfacePredType st; return (PredTy st') }

tcIfaceTypes :: [IfaceType] -> IfL [Type]
tcIfaceTypes tys = mapM tcIfaceType tys

-----------------------------------------
tcIfacePredType :: IfacePredType -> IfL PredType
tcIfacePredType (IfaceClassP cls ts) = do { cls' <- tcIfaceClass cls; ts' <- tcIfaceTypes ts; return (ClassP cls' ts') }
tcIfacePredType (IfaceIParam ip t)   = do { ip' <- newIPName ip; t' <- tcIfaceType t; return (IParam ip' t') }
tcIfacePredType (IfaceEqPred t1 t2)  = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (EqPred t1' t2') }

-----------------------------------------
tcIfaceCtxt :: IfaceContext -> IfL ThetaType
tcIfaceCtxt sts = mapM tcIfacePredType sts

tcIfaceExpr :: IfaceExpr -> IfL CoreExpr
tcIfaceExpr (IfaceType ty)
  = Type <$> tcIfaceType ty

tcIfaceExpr (IfaceLcl name)
  = Var <$> tcIfaceLclId name

tcIfaceExpr (IfaceTick modName tickNo)
  = Var <$> tcIfaceTick modName tickNo

tcIfaceExpr (IfaceExt gbl)
  = Var <$> tcIfaceExtId gbl

tcIfaceExpr (IfaceLit lit)
  = return (Lit lit)

tcIfaceExpr (IfaceFCall cc ty) = do
    ty' <- tcIfaceType ty
    u <- newUnique
    return (Var (mkFCallId u cc ty'))

tcIfaceExpr (IfaceTuple boxity args)  = do
    args' <- mapM tcIfaceExpr args
    -- Put the missing type arguments back in
    let con_args = map (Type . exprType) args' ++ args'
    return (mkApps (Var con_id) con_args)
  where
    arity = length args
    con_id = dataConWorkId (tupleCon boxity arity)
    

tcIfaceExpr (IfaceLam bndr body)
  = bindIfaceBndr bndr $ \bndr' ->
    Lam bndr' <$> tcIfaceExpr body

tcIfaceExpr (IfaceApp fun arg)
  = App <$> tcIfaceExpr fun <*> tcIfaceExpr arg

tcIfaceExpr (IfaceCase scrut case_bndr ty alts)  = do
    scrut' <- tcIfaceExpr scrut
    case_bndr_name <- newIfaceName (mkVarOccFS case_bndr)
    let
	scrut_ty   = exprType scrut'
	case_bndr' = mkLocalId case_bndr_name scrut_ty
	tc_app     = splitTyConApp scrut_ty
		-- NB: Won't always succeed (polymoprhic case)
		--     but won't be demanded in those cases
		-- NB: not tcSplitTyConApp; we are looking at Core here
		--     look through non-rec newtypes to find the tycon that
		--     corresponds to the datacon in this case alternative

    extendIfaceIdEnv [case_bndr'] $ do
     alts' <- mapM (tcIfaceAlt scrut' tc_app) alts
     ty' <- tcIfaceType ty
     return (Case scrut' case_bndr' ty' alts')

tcIfaceExpr (IfaceLet (IfaceNonRec (IfLetBndr fs ty info) rhs) body)
  = do	{ name 	  <- newIfaceName (mkVarOccFS fs)
	; ty'  	  <- tcIfaceType ty
        ; id_info <- tcIdInfo False {- Don't ignore prags; we are inside one! -}
                              name ty' info
	; let id = mkLocalIdWithInfo name ty' id_info
        ; rhs' <- tcIfaceExpr rhs
        ; body' <- extendIfaceIdEnv [id] (tcIfaceExpr body)
        ; return (Let (NonRec id rhs') body') }

tcIfaceExpr (IfaceLet (IfaceRec pairs) body)
  = do { ids <- mapM tc_rec_bndr (map fst pairs)
       ; extendIfaceIdEnv ids $ do
       { pairs' <- zipWithM tc_pair pairs ids
       ; body' <- tcIfaceExpr body
       ; return (Let (Rec pairs') body') } }
 where
   tc_rec_bndr (IfLetBndr fs ty _) 
     = do { name <- newIfaceName (mkVarOccFS fs)  
          ; ty'  <- tcIfaceType ty
          ; return (mkLocalId name ty') }
   tc_pair (IfLetBndr _ _ info, rhs) id
     = do { rhs' <- tcIfaceExpr rhs
          ; id_info <- tcIdInfo False {- Don't ignore prags; we are inside one! -}
                                (idName id) (idType id) info
          ; return (setIdInfo id id_info, rhs') }

tcIfaceExpr (IfaceCast expr co) = do
    expr' <- tcIfaceExpr expr
    co' <- tcIfaceType co
    return (Cast expr' co')

tcIfaceExpr (IfaceNote note expr) = do
    expr' <- tcIfaceExpr expr
    case note of
        IfaceSCC cc       -> return (Note (SCC cc)   expr')
        IfaceCoreNote n   -> return (Note (CoreNote n) expr')

-------------------------
tcIfaceAlt :: CoreExpr -> (TyCon, [Type])
           -> (IfaceConAlt, [FastString], IfaceExpr)
           -> IfL (AltCon, [TyVar], CoreExpr)
tcIfaceAlt _ _ (IfaceDefault, names, rhs)
  = ASSERT( null names ) do
    rhs' <- tcIfaceExpr rhs
    return (DEFAULT, [], rhs')
  
tcIfaceAlt _ _ (IfaceLitAlt lit, names, rhs)
  = ASSERT( null names ) do
    rhs' <- tcIfaceExpr rhs
    return (LitAlt lit, [], rhs')

-- A case alternative is made quite a bit more complicated
-- by the fact that we omit type annotations because we can
-- work them out.  True enough, but its not that easy!
tcIfaceAlt scrut (tycon, inst_tys) (IfaceDataAlt data_occ, arg_strs, rhs)
  = do	{ con <- tcIfaceDataCon data_occ
	; when (debugIsOn && not (con `elem` tyConDataCons tycon))
	       (failIfM (ppr scrut $$ ppr con $$ ppr tycon $$ ppr (tyConDataCons tycon)))
	; tcIfaceDataAlt con inst_tys arg_strs rhs }
		  
tcIfaceAlt _ (tycon, inst_tys) (IfaceTupleAlt _boxity, arg_occs, rhs)
  = ASSERT2( isTupleTyCon tycon, ppr tycon )
    do	{ let [data_con] = tyConDataCons tycon
	; tcIfaceDataAlt data_con inst_tys arg_occs rhs }

tcIfaceDataAlt :: DataCon -> [Type] -> [FastString] -> IfaceExpr
               -> IfL (AltCon, [TyVar], CoreExpr)
tcIfaceDataAlt con inst_tys arg_strs rhs
  = do	{ us <- newUniqueSupply
	; let uniqs = uniqsFromSupply us
	; let (ex_tvs, co_tvs, arg_ids)
	              = dataConRepFSInstPat arg_strs uniqs con inst_tys
              all_tvs = ex_tvs ++ co_tvs

	; rhs' <- extendIfaceTyVarEnv all_tvs	$
		  extendIfaceIdEnv arg_ids	$
		  tcIfaceExpr rhs
	; return (DataAlt con, all_tvs ++ arg_ids, rhs') }

tcExtCoreBindings :: [IfaceBinding] -> IfL [CoreBind]	-- Used for external core
tcExtCoreBindings []     = return []
tcExtCoreBindings (b:bs) = do_one b (tcExtCoreBindings bs)

do_one :: IfaceBinding -> IfL [CoreBind] -> IfL [CoreBind]
do_one (IfaceNonRec bndr rhs) thing_inside
  = do	{ rhs' <- tcIfaceExpr rhs
	; bndr' <- newExtCoreBndr bndr
	; extendIfaceIdEnv [bndr'] $ do 
	{ core_binds <- thing_inside
	; return (NonRec bndr' rhs' : core_binds) }}

do_one (IfaceRec pairs) thing_inside
  = do	{ bndrs' <- mapM newExtCoreBndr bndrs
	; extendIfaceIdEnv bndrs' $ do
 	{ rhss' <- mapM tcIfaceExpr rhss
	; core_binds <- thing_inside
	; return (Rec (bndrs' `zip` rhss') : core_binds) }}
  where
    (bndrs,rhss) = unzip pairs

tcIdDetails :: Type -> IfaceIdDetails -> IfL IdDetails
tcIdDetails _  IfVanillaId = return VanillaId
tcIdDetails ty (IfDFunId ns)
  = return (DFunId ns (isNewTyCon (classTyCon cls)))
  where
    (_, cls, _) = tcSplitDFunTy ty

tcIdDetails _ (IfRecSelId tc naughty)
  = do { tc' <- tcIfaceTyCon tc
       ; return (RecSelId { sel_tycon = tc', sel_naughty = naughty }) }

tcIdInfo :: Bool -> Name -> Type -> IfaceIdInfo -> IfL IdInfo
tcIdInfo ignore_prags name ty info 
  | ignore_prags = return vanillaIdInfo
  | otherwise    = case info of
			NoInfo       -> return vanillaIdInfo
			HasInfo info -> foldlM tcPrag init_info info
  where
    -- Set the CgInfo to something sensible but uninformative before
    -- we start; default assumption is that it has CAFs
    init_info = vanillaIdInfo

    tcPrag :: IdInfo -> IfaceInfoItem -> IfL IdInfo
    tcPrag info HsNoCafRefs        = return (info `setCafInfo`   NoCafRefs)
    tcPrag info (HsArity arity)    = return (info `setArityInfo` arity)
    tcPrag info (HsStrictness str) = return (info `setStrictnessInfo` Just str)
    tcPrag info (HsInline prag)    = return (info `setInlinePragInfo` prag)

	-- The next two are lazy, so they don't transitively suck stuff in
    tcPrag info (HsUnfold lb if_unf) 
      = do { unf <- tcUnfolding name ty info if_unf
    	   ; let info1 | lb        = info `setOccInfo` nonRuleLoopBreaker
	     	       | otherwise = info
	   ; return (info1 `setUnfoldingInfoLazily` unf) }

tcUnfolding :: Name -> Type -> IdInfo -> IfaceUnfolding -> IfL Unfolding
tcUnfolding name _ info (IfCoreUnfold stable if_expr)
  = do 	{ mb_expr <- tcPragExpr name if_expr
        ; let unf_src = if stable then InlineStable else InlineRhs
	; return (case mb_expr of
		    Nothing   -> NoUnfolding
		    Just expr -> mkUnfolding unf_src
                                             True {- Top level -} 
                                             is_bottoming expr) }
  where
     -- Strictness should occur before unfolding!
    is_bottoming = case strictnessInfo info of
    		     Just sig -> isBottomingSig sig
 		     Nothing  -> False

tcUnfolding name _ _ (IfCompulsory if_expr)
  = do 	{ mb_expr <- tcPragExpr name if_expr
	; return (case mb_expr of
		    Nothing   -> NoUnfolding
		    Just expr -> mkCompulsoryUnfolding expr) }

tcUnfolding name _ _ (IfInlineRule arity unsat_ok boring_ok if_expr)
  = do 	{ mb_expr <- tcPragExpr name if_expr
	; return (case mb_expr of
		    Nothing   -> NoUnfolding
		    Just expr -> mkCoreUnfolding InlineStable True expr arity 
                                                 (UnfWhen unsat_ok boring_ok))
    }

tcUnfolding name dfun_ty _ (IfDFunUnfold ops)
  = do { mb_ops1 <- forkM_maybe doc $ mapM tc_arg ops
       ; return (case mb_ops1 of
       	 	    Nothing   -> noUnfolding
                    Just ops1 -> mkDFunUnfolding dfun_ty ops1) }
  where
    doc = text "Class ops for dfun" <+> ppr name
    tc_arg (DFunPolyArg  e) = do { e' <- tcIfaceExpr e; return (DFunPolyArg e') }
    tc_arg (DFunConstArg e) = do { e' <- tcIfaceExpr e; return (DFunConstArg e') }
    tc_arg (DFunLamArg i)   = return (DFunLamArg i)

tcUnfolding name ty info (IfExtWrapper arity wkr)
  = tcIfaceWrapper name ty info arity (tcIfaceExtId wkr)
tcUnfolding name ty info (IfLclWrapper arity wkr)
  = tcIfaceWrapper name ty info arity (tcIfaceLclId wkr)

-------------
tcIfaceWrapper :: Name -> Type -> IdInfo -> Arity -> IfL Id -> IfL Unfolding
tcIfaceWrapper name ty info arity get_worker
  = do 	{ mb_wkr_id <- forkM_maybe doc get_worker
	; us <- newUniqueSupply
	; return (case mb_wkr_id of
		     Nothing     -> noUnfolding
		     Just wkr_id -> make_inline_rule wkr_id us) }
  where
    doc = text "Worker for" <+> ppr name

    make_inline_rule wkr_id us 
	= mkWwInlineRule wkr_id
	  		 (initUs_ us (mkWrapper ty strict_sig) wkr_id) 
		         arity

    	-- Again we rely here on strictness info always appearing 
	-- before unfolding
    strict_sig = case strictnessInfo info of
		   Just sig -> sig
		   Nothing  -> pprPanic "Worker info but no strictness for" (ppr name)

tcPragExpr :: Name -> IfaceExpr -> IfL (Maybe CoreExpr)
tcPragExpr name expr
  = forkM_maybe doc $ do
    core_expr' <- tcIfaceExpr expr

                -- Check for type consistency in the unfolding
    ifDOptM Opt_DoCoreLinting $ do
        in_scope <- get_in_scope
        case lintUnfolding noSrcLoc in_scope core_expr' of
          Nothing       -> return ()
          Just fail_msg -> do { mod <- getIfModule 
                              ; pprPanic "Iface Lint failure" 
                                  (vcat [ ptext (sLit "In interface for") <+> ppr mod
                                        , hang doc 2 fail_msg
                                        , ppr name <+> equals <+> ppr core_expr'
                                        , ptext (sLit "Iface expr =") <+> ppr expr ]) }
    return core_expr'
  where
    doc = text "Unfolding of" <+> ppr name

    get_in_scope :: IfL [Var] -- Totally disgusting; but just for linting
    get_in_scope 	
	= do { (gbl_env, lcl_env) <- getEnvs
             ; rec_ids <- case if_rec_types gbl_env of
                            Nothing -> return []
                            Just (_, get_env) -> do
                               { type_env <- setLclEnv () get_env
                               ; return (typeEnvIds type_env) }
             ; return (varEnvElts (if_tv_env lcl_env) ++
                       varEnvElts (if_id_env lcl_env) ++
                       rec_ids) }

tcIfaceGlobal :: Name -> IfL TyThing
tcIfaceGlobal name
  | Just thing <- wiredInNameTyThing_maybe name
	-- Wired-in things include TyCons, DataCons, and Ids
  = do { ifCheckWiredInThing thing; return thing }
  | otherwise
  = do	{ env <- getGblEnv
	; case if_rec_types env of {	-- Note [Tying the knot]
	    Just (mod, get_type_env) 
		| nameIsLocalOrFrom mod name
		-> do 		-- It's defined in the module being compiled
	  	{ type_env <- setLclEnv () get_type_env		-- yuk
		; case lookupNameEnv type_env name of
			Just thing -> return thing
			Nothing	  -> pprPanic "tcIfaceGlobal (local): not found:"  
						(ppr name $$ ppr type_env) }

	  ; _ -> do

	{ hsc_env <- getTopEnv
        ; mb_thing <- liftIO (lookupTypeHscEnv hsc_env name)
	; case mb_thing of {
	    Just thing -> return thing ;
	    Nothing    -> do

	{ mb_thing <- importDecl name 	-- It's imported; go get it
	; case mb_thing of
	    Failed err      -> failIfM err
	    Succeeded thing -> return thing
    }}}}}

-- Note [Tying the knot]
-- ~~~~~~~~~~~~~~~~~~~~~
-- The if_rec_types field is used in two situations:
--
-- a) Compiling M.hs, which indiretly imports Foo.hi, which mentions M.T
--    Then we look up M.T in M's type environment, which is splatted into if_rec_types
--    after we've built M's type envt.
--
-- b) In ghc --make, during the upsweep, we encounter M.hs, whose interface M.hi
--    is up to date.  So we call typecheckIface on M.hi.  This splats M.T into 
--    if_rec_types so that the (lazily typechecked) decls see all the other decls
--
-- In case (b) it's important to do the if_rec_types check *before* looking in the HPT
-- Because if M.hs also has M.hs-boot, M.T will *already be* in the HPT, but in its
-- emasculated form (e.g. lacking data constructors).

tcIfaceTyCon :: IfaceTyCon -> IfL TyCon
tcIfaceTyCon IfaceIntTc       	= tcWiredInTyCon intTyCon
tcIfaceTyCon IfaceBoolTc      	= tcWiredInTyCon boolTyCon
tcIfaceTyCon IfaceCharTc      	= tcWiredInTyCon charTyCon
tcIfaceTyCon IfaceListTc      	= tcWiredInTyCon listTyCon
tcIfaceTyCon IfacePArrTc      	= tcWiredInTyCon parrTyCon
tcIfaceTyCon (IfaceTupTc bx ar) = tcWiredInTyCon (tupleTyCon bx ar)
tcIfaceTyCon (IfaceAnyTc kind)  = do { tc_kind <- tcIfaceType kind
                                     ; tcWiredInTyCon (anyTyConOfKind tc_kind) }
tcIfaceTyCon (IfaceTc name)     = do { thing <- tcIfaceGlobal name 
				     ; return (check_tc (tyThingTyCon thing)) }
  where
    check_tc tc
     | debugIsOn = case toIfaceTyCon tc of
                   IfaceTc _ -> tc
                   _         -> pprTrace "check_tc" (ppr tc) tc
     | otherwise = tc
-- we should be okay just returning Kind constructors without extra loading
tcIfaceTyCon IfaceLiftedTypeKindTc   = return liftedTypeKindTyCon
tcIfaceTyCon IfaceOpenTypeKindTc     = return openTypeKindTyCon
tcIfaceTyCon IfaceUnliftedTypeKindTc = return unliftedTypeKindTyCon
tcIfaceTyCon IfaceArgTypeKindTc      = return argTypeKindTyCon
tcIfaceTyCon IfaceUbxTupleKindTc     = return ubxTupleKindTyCon

-- Even though we are in an interface file, we want to make
-- sure the instances and RULES of this tycon are loaded 
-- Imagine: f :: Double -> Double
tcWiredInTyCon :: TyCon -> IfL TyCon
tcWiredInTyCon tc = do { ifCheckWiredInThing (ATyCon tc)
		       ; return tc }

tcIfaceClass :: Name -> IfL Class
tcIfaceClass name = do { thing <- tcIfaceGlobal name
		       ; return (tyThingClass thing) }

tcIfaceDataCon :: Name -> IfL DataCon
tcIfaceDataCon name = do { thing <- tcIfaceGlobal name
		 	 ; case thing of
				ADataCon dc -> return dc
				_       -> pprPanic "tcIfaceExtDC" (ppr name$$ ppr thing) }

tcIfaceExtId :: Name -> IfL Id
tcIfaceExtId name = do { thing <- tcIfaceGlobal name
		       ; case thing of
			  AnId id -> return id
			  _       -> pprPanic "tcIfaceExtId" (ppr name$$ ppr thing) }

bindIfaceBndr :: IfaceBndr -> (CoreBndr -> IfL a) -> IfL a
bindIfaceBndr (IfaceIdBndr (fs, ty)) thing_inside
  = do	{ name <- newIfaceName (mkVarOccFS fs)
	; ty' <- tcIfaceType ty
	; let id = mkLocalId name ty'
	; extendIfaceIdEnv [id] (thing_inside id) }
bindIfaceBndr (IfaceTvBndr bndr) thing_inside
  = bindIfaceTyVar bndr thing_inside
    
bindIfaceBndrs :: [IfaceBndr] -> ([CoreBndr] -> IfL a) -> IfL a
bindIfaceBndrs []     thing_inside = thing_inside []
bindIfaceBndrs (b:bs) thing_inside
  = bindIfaceBndr b	$ \ b' ->
    bindIfaceBndrs bs	$ \ bs' ->
    thing_inside (b':bs')

-----------------------
newExtCoreBndr :: IfaceLetBndr -> IfL Id
newExtCoreBndr (IfLetBndr var ty _)    -- Ignoring IdInfo for now
  = do	{ mod <- getIfModule
	; name <- newGlobalBinder mod (mkVarOccFS var) noSrcSpan
	; ty' <- tcIfaceType ty
	; return (mkLocalId name ty') }

-----------------------
bindIfaceTyVar :: IfaceTvBndr -> (TyVar -> IfL a) -> IfL a
bindIfaceTyVar (occ,kind) thing_inside
  = do	{ name <- newIfaceName (mkTyVarOccFS occ)
   	; tyvar <- mk_iface_tyvar name kind
	; extendIfaceTyVarEnv [tyvar] (thing_inside tyvar) }

bindIfaceTyVars :: [IfaceTvBndr] -> ([TyVar] -> IfL a) -> IfL a
bindIfaceTyVars bndrs thing_inside
  = do	{ names <- newIfaceNames (map mkTyVarOccFS occs)
  	; tyvars <- zipWithM mk_iface_tyvar names kinds
	; extendIfaceTyVarEnv tyvars (thing_inside tyvars) }
  where
    (occs,kinds) = unzip bndrs

mk_iface_tyvar :: Name -> IfaceKind -> IfL TyVar
mk_iface_tyvar name ifKind
   = do { kind <- tcIfaceType ifKind
	; if isCoercionKind kind then 
		return (Var.mkCoVar name kind)
	  else
		return (Var.mkTyVar name kind) }

bindIfaceTyVars_AT :: [IfaceTvBndr] -> ([TyVar] -> IfL a) -> IfL a
-- Used for type variable in nested associated data/type declarations
-- where some of the type variables are already in scope
--    class C a where { data T a b }
-- Here 'a' is in scope when we look at the 'data T'
bindIfaceTyVars_AT [] thing_inside
  = thing_inside []
bindIfaceTyVars_AT (b@(tv_occ,_) : bs) thing_inside 
  = bindIfaceTyVars_AT bs $ \ bs' ->
    do { mb_tv <- lookupIfaceTyVar tv_occ
       ; case mb_tv of
      	   Just b' -> thing_inside (b':bs')
	   Nothing -> bindIfaceTyVar b $ \ b' -> 
	   	      thing_inside (b':bs') }