[project @ 1996-06-11 13:18:54 by partain]

[ghc-hetmet.git] / ghc / compiler / utils / Ubiq.lhi

diff --git a/ghc/compiler/utils/Ubiq.lhi b/ghc/compiler/utils/Ubiq.lhi
index 20e54b3..1632c4b 100644 (file)
--- a/ghc/compiler/utils/Ubiq.lhi
+++ b/ghc/compiler/utils/Ubiq.lhi
@@ -7,40 +7,45 @@ import PreludePS(_PackedString)
 
 import Bag             ( Bag )
 import BinderInfo      ( BinderInfo )
+import CgBindery       ( CgIdInfo )
+import CharSeq         ( CSeq )
+import CLabel          ( CLabel )
 import Class           ( GenClass, GenClassOp, Class(..), ClassOp )
+import ClosureInfo     ( ClosureInfo, LambdaFormInfo )
 import CmdLineOpts     ( SimplifierSwitch, SwitchResult )
 import CoreSyn         ( GenCoreArg, GenCoreBinder, GenCoreBinding, GenCoreExpr,
-                         GenCoreCaseAlts, GenCoreCaseDefault
+                         GenCoreCaseAlts, GenCoreCaseDefault, Coercion
                        )
 import CoreUnfold      ( UnfoldingDetails, UnfoldingGuidance )
 import CostCentre      ( CostCentre )
+import FieldLabel      ( FieldLabel )
 import FiniteMap       ( FiniteMap )
+import HeapOffs                ( HeapOffset )
 import HsCore          ( UnfoldingCoreExpr )
 import HsPat           ( OutPat )
-import HsPragmas       ( ClassOpPragmas, ClassPragmas, DataPragmas, GenPragmas,
-                         InstancePragmas
-                       )
+import HsPragmas       ( ClassOpPragmas, ClassPragmas, DataPragmas, GenPragmas, InstancePragmas )
 import Id              ( StrictnessMark, GenId, Id(..) )
-import IdInfo          ( IdInfo, OptIdInfo(..), DeforestInfo, Demand, StrictnessInfo, UpdateInfo )
+import IdInfo          ( IdInfo, OptIdInfo(..), ArityInfo, DeforestInfo, Demand, StrictnessInfo, UpdateInfo )
 import Kind            ( Kind )
 import Literal         ( Literal )
+import MachRegs                ( Reg )
 import Maybes          ( MaybeErr )
 import MatchEnv        ( MatchEnv )
-import Name            ( Name )
-import NameTypes       ( FullName, ShortName )
-import Outputable      ( ExportFlag, NamedThing(..), Outputable(..) )
+import Name            ( Module(..), OrigName, RdrName, Name, ExportFlag, NamedThing(..) )
+import Outputable      ( Outputable(..) )
 import PprStyle                ( PprStyle )
 import PragmaInfo      ( PragmaInfo )
 import Pretty          ( PrettyRep )
 import PrimOp          ( PrimOp )
 import PrimRep         ( PrimRep )
-import ProtoName       ( ProtoName )
+import RnHsSyn         ( RnName )
+import SMRep           ( SMRep )
 import SrcLoc          ( SrcLoc )
 import TcType          ( TcMaybe )
 import TyCon           ( TyCon, Arity(..) )
 import TyVar           ( GenTyVar, TyVar(..) )
 import Type            ( GenType, Type(..) )
-import UniqFM          ( UniqFM )
+import UniqFM          ( UniqFM, Uniquable(..) )
 import UniqSupply      ( UniqSupply )
 import Unique          ( Unique )
 import Usage           ( GenUsage, Usage(..) )
@@ -50,14 +55,7 @@ import Util          ( Ord3(..) )
 -- to try to contain their visibility.
 
 class NamedThing a where
-       getExportFlag :: a -> ExportFlag
-       isLocallyDefined :: a -> Bool
-       getOrigName :: a -> (_PackedString, _PackedString)
-       getOccurrenceName :: a -> _PackedString
-       getInformingModules :: a -> [_PackedString]
-       getSrcLoc :: a -> SrcLoc
-       getItsUnique :: a -> Unique
-       fromPreludeCore :: a -> Bool
+       getName :: a -> Name
 class OptIdInfo a where
        noInfo  :: a
        getInfo :: IdInfo -> a
@@ -67,22 +65,30 @@ class Ord3 a where
        cmp :: a -> a -> Int#
 class Outputable a where
        ppr :: PprStyle -> a -> Int -> Bool -> PrettyRep
+class Uniquable a where
+       uniqueOf :: a -> Unique
 
 -- For datatypes, we ubiquitize those types that (a) are
 -- used everywhere and (b) the compiler doesn't lose much
 -- optimisation-wise by not seeing their pragma-gunk.
 
+data ArityInfo
 data Bag a
 data BinderInfo
+data CgIdInfo
+data CLabel
 data ClassOpPragmas a
 data ClassPragmas a
+data ClosureInfo
+data Coercion
 data CostCentre
+data CSeq
 data DataPragmas a
 data DeforestInfo
 data Demand
 data ExportFlag
+data FieldLabel
 data FiniteMap a b
-data FullName  -- NB: fails the optimisation criterion
 data GenClass a b
 data GenClassOp a
 data GenCoreArg a b c
@@ -96,22 +102,27 @@ data GenPragmas a
 data GenTyVar a        -- NB: fails the optimisation criterion
 data GenType  a b
 data GenUsage a
+data HeapOffset
 data IdInfo
 data InstancePragmas a
 data Kind
+data LambdaFormInfo
 data Literal
 data MaybeErr a b
 data MatchEnv a b
 data Name
+data OrigName = OrigName _PackedString _PackedString
+data RdrName = Unqual _PackedString | Qual _PackedString _PackedString
+data Reg
 data OutPat a b c
 data PprStyle
 data PragmaInfo
 data PrettyRep
 data PrimOp
 data PrimRep   -- NB: an enumeration
-data ProtoName
-data ShortName -- NB: fails the optimisation criterion
+data RnName
 data SimplifierSwitch
+data SMRep
 data SrcLoc
 data StrictnessInfo
 data StrictnessMark
@@ -128,6 +139,7 @@ data Unique -- NB: fails the optimisation criterion
 
 -- don't get clever and unexpand some of these synonyms
 -- (GHC 0.26 will barf)
+type Module = _PackedString
 type Arity = Int
 type Class = GenClass (GenTyVar (GenUsage Unique)) Unique
 type ClassOp = GenClassOp (GenType (GenTyVar (GenUsage Unique)) Unique)
@@ -135,4 +147,14 @@ type Id       = GenId (GenType (GenTyVar (GenUsage Unique)) Unique)
 type Type  = GenType (GenTyVar (GenUsage Unique)) Unique
 type TyVar = GenTyVar (GenUsage Unique)
 type Usage = GenUsage Unique
+
+-- These are here only for SPECIALIZing in FiniteMap (ToDo:move?)
+instance Ord Reg
+instance Ord RdrName
+instance Ord CLabel
+instance Ord TyCon
+instance Eq Reg
+instance Eq RdrName
+instance Eq CLabel
+instance Eq TyCon
 \end{code}