+ tycon = mkAlgTyCon tycon_name tycon_kind tyvars ctxt argvrcs
+ data_cons nconstrs sel_ids
+ flavour is_rec gen_info
+
+ gen_info | not (dopt Opt_Generics dflags) = Nothing
+ | otherwise = mkTyConGenInfo tycon sys_names
+
+ DataTyDetails ctxt data_cons sel_ids = lookupNameEnv_NF rec_details tycon_name
+
+ tycon_kind = lookupNameEnv_NF kenv tycon_name
+ tyvars = mkTyClTyVars tycon_kind tyvar_names
+ argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon
+
+ -- Watch out! mkTyConApp asks whether the tycon is a NewType,
+ -- so flavour has to be able to answer this question without consulting rec_details
+ flavour = case data_or_new of
+ NewType -> NewTyCon (mkNewTyConRep tycon)
+ DataType | all (null . dataConOrigArgTys) data_cons -> EnumTyCon
+ | otherwise -> DataTyCon
+ -- NB (null . dataConOrigArgTys). It used to say isNullaryDataCon
+ -- but that looks at the *representation* arity, and that in turn
+ -- depends on deciding whether to unpack the args, and that
+ -- depends on whether it's a data type or a newtype --- so
+ -- in the recursive case we can get a loop. This version is simple!
+
+buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details
+ (ForeignType {tcdName = tycon_name, tcdExtName = tycon_ext_name})
+ = ATyCon (mkForeignTyCon tycon_name tycon_ext_name liftedTypeKind 0 [])
+
+buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details
+ (ClassDecl {tcdName = class_name, tcdTyVars = tyvar_names,
+ tcdFDs = fundeps, tcdSysNames = name_list} )
+ = AClass clas
+ where
+ (tycon_name, _, _, _) = getClassDeclSysNames name_list
+ clas = mkClass class_name tyvars fds
+ sc_theta sc_sel_ids op_items
+ tycon
+
+ tycon = mkClassTyCon tycon_name class_kind tyvars
+ argvrcs dict_con
+ clas -- Yes! It's a dictionary
+ flavour
+ is_rec
+ -- A class can be recursive, and in the case of newtypes
+ -- this matters. For example
+ -- class C a where { op :: C b => a -> b -> Int }
+ -- Because C has only one operation, it is represented by
+ -- a newtype, and it should be a *recursive* newtype.
+ -- [If we don't make it a recursive newtype, we'll expand the
+ -- newtype like a synonym, but that will lead toan inifinite type
+
+ ClassDetails sc_theta sc_sel_ids op_items dict_con = lookupNameEnv_NF rec_details class_name
+
+ class_kind = lookupNameEnv_NF kenv class_name
+ tyvars = mkTyClTyVars class_kind tyvar_names
+ argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon
+
+ flavour = case dataConOrigArgTys dict_con of
+ -- The tyvars in the datacon are the same as in the class
+ [rep_ty] -> NewTyCon rep_ty
+ other -> DataTyCon
+
+ -- We can find the functional dependencies right away,
+ -- and it is vital to do so. Why? Because in the next pass
+ -- we check for ambiguity in all the type signatures, and we
+ -- need the functional dependcies to be done by then
+ fds = [(map lookup xs, map lookup ys) | (xs,ys) <- fundeps]
+ tyvar_env = mkNameEnv [(varName tv, tv) | tv <- tyvars]
+ lookup = lookupNameEnv_NF tyvar_env
+
+bogusVrcs = panic "Bogus tycon arg variances"