Changes between Version 1 and Version 2 of ModuleDependencies/Hierarchical


Ignore:
Timestamp:
Oct 27, 2008 1:06:13 PM (7 years ago)
Author:
nominolo
Comment:

update based on discussion with simonmar

Legend:

Unmodified
Added
Removed
Modified
  • ModuleDependencies/Hierarchical

    v1 v2  
    22
    33{{{
     4what to do with C stuff?
     5
     6principles (so far) (correct/mark violations):
     7  - try to be consistent (i.e., either always use Decl or always use Declaration)
     8  - "Types" is a collection of types to be used in the compiler
     9  - "Type" is related to working with (a representation) of a Haskell type
     10
     11------------------------------------------------------------------------------------
     12
    413what to do with C stuff?
    514
     
    1019  - "Type" is related to working with (a representation) of a Haskell type
    1120
    12 ------------------------------------------------------------------------------------
    1321
    1422main/
    1523  GHC.hs                        GHC -- could use some further splitting up
     24                                GHC.Make  -- parts of GHC.hs (depanal, etc.)
    1625  Config.hs                     GHC.Config
    1726  Constants.lhs                 GHC.Config.Constants
    18   ParsePkgConf.y                GHC.Config.Packages.Parser
    19   StaticFlagParser.hs           GHC.Config.[Flags.Static/StaticFlags].Parser
    20   StaticFlags.hs                GHC.Config.[Flags.Static/StaticFlags]
    21                                 GHC.Driver.Make
    22   DriverMkDepend.hs             GHC.Driver.Depend -- ?
     27  ParsePkgConf.y                GHC.Config.Packages.Parse
     28  PackageConfig.hs              GHC.Config.Package[s]
     29  StaticFlags.hs                GHC.[Config.]Flags.Static
     30  StaticFlagParser.hs           GHC.[Config.]Flags.Static.Parse
     31  DynFlags.hs                   GHC.[Config.]Flags.Dynamic
     32  DriverMkDepend.hs             GHC.[Driver.Depend/MkDepend] -- it's a
     33                                 or: GHC.MakeDepend  -- since it's a GHC API client
    2334  DriverPhases.hs               GHC.Driver.Phase[s] -- ?
    2435  DriverPipeline.hs             GHC.Driver.Pipeline  -- ?
    2536  HeaderInfo.hs                 GHC.Driver.HeaderInfo -- (used by DriverPipeline, GHC)
     37                                 or: GHC.Parse.HeaderInfo
    2638  HscMain.lhs                   GHC.Compiler
    2739  HscStats.lhs                  GHC.Compiler.Stats -- only used by HscMain
    2840  CodeOutput.lhs                GHC.Compiler.CodeOutput -- ?
    29   CmdLineParser.hs              GHC.CmdLine.Parser
    30   DynFlags.hs                   GHC.Config.[Flags.Dynamic/DynFlags]
     41  CmdLineParser.hs              GHC.CmdLine.Parse
    3142  Finder.lhs                    GHC.Finder
    32   HscTypes.lhs/boot             GHC.[Types/DumpHereIfUnsure] -- ideas?  split up how?
     43  HscTypes.lhs/boot             GHC.Types    -- very hard to split up
    3344  InteractiveEval.hs/boot       GHC.Interactive
    34   PackageConfig.hs              GHC.Config.Package[s]
    35   Packages.lhs/boot             GHC.Package[s]
     45  Packages.lhs/boot             GHC.Package[s] -- ?
    3646  PprTyThing.hs                 GHC.Interactive.PprTyThing -- ? (used by InteractiveUI, Debugger)
    3747  SysTools.lhs                  GHC.[Driver.]SysTools -- used by GHC, DriverPipeline, DriverMkDepend
    3848  TidyPgm.lhs                   GHC.Core.Tidy.Program -- ?
    39   BreakArray.hs                 GHC.[Interactive.]Utils.BreakArray
     49  BreakArray.hs                 GHC.Utils.BreakArray
    4050  ErrUtils.lhs/boot             GHC.Utils.Error -- depends on StaticFlags, DynFlags, SrcLoc,
    4151
     
    4656  ByteCodeInstr.lhs             GHC.ByteCode.Instruction[s]
    4757  ByteCodeItbls.lhs             GHC.ByteCode.InfoTable[s]
    48   ByteCodeLink.lhs/boot         GHC.[ByteCode.Link/Link.ByteCode]
     58  ByteCodeLink.lhs/boot         GHC.[ByteCode.Link/Link.ByteCode] -- difference to GHC.Interactive.Link?
    4959  Debugger.hs                   GHC.Interactive.Debugger
    5060  GhciMonad.hs                  GHCi.Monad
    5161  GhciTags.hs                   GHCi.Tags
    52   InteractiveUI.hs              GHCi.[UI/Interface] -- possibly further split-up
    53   LibFFI.hsc                    GHCi.ByteCode.[Generate.]FFI -- used only by ByteCodeGen
    54   Linker.lhs                    GHC.Link[er]
    55   ObjLink.lhs                   GHC.Link.Object[Code]
     62  InteractiveUI.hs              GHCi.UI  -- possibly further split-up
     63  LibFFI.hsc                    GHCi.ByteCode.LibFFI -- this is a libffi binding
     64  Linker.lhs                    GHC.Interactive.Link -- or Linker?
     65  ObjLink.lhs                   GHC.Interactive.Link.ObjCode
    5666  RtClosureInspect.hs           GHC.[ByteCode].ClosureInspect
    5767  keepCAFsForGHCi.c
     
    7484  GraphColor.hs                 GHC.Utils.Graph.Colo[u]r
    7585  GraphOps.hs                   GHC.Utils.Graph.Operations
    76   GraphPpr.hs                   GHC.Utils.PrettyPrint
     86  GraphPpr.hs                   GHC.Utils.Graph.PrettyPrint
    7787  IOEnv.hs                      GHC.[Utils.]Monad.IOEnv
    7888  Interval.hs                   GHC.Utils.Interval
     
    99109  DataCon.lhs/boot              GHC.Types.DataCon
    100110  Demand.lhs                    GHC.Types.Demand.Old
    101   Id.lhs                        GHC.Names.Id
    102   IdInfo.lhs/boot               GHC.Names.Id.Info
    103   Literal.lhs                   GHC.[Names/Type[s]].Literal
    104   MkId.lhs/boot                 GHC.Names.Id.Make
    105   Module.lhs/boot               GHC.Names.Module
    106                                 -- extract? GHC.Types.ModLocation
    107                                 -- GHC.Types.<bla> ?
    108   Name.lhs/boot                 GHC.Names.Name
    109   NameEnv.lhs                   GHC.Names.Name.Env[ironment]
    110   NameSet.lhs                   GHC.Names.Name.Set
     111  Id.lhs                        GHC.Types.Id
     112  IdInfo.lhs/boot               GHC.Types.Id.Info
     113  MkId.lhs/boot                 GHC.Types.Id.Make
     114  Var.lhs                       GHC.Types.Var
     115  VarEnv.lhs                    GHC.Types.Var.Env
     116  VarSet.lhs                    GHC.Types.Var.Set
     117  OccName.lhs/boot              GHC.Types.OccName
     118  RdrName.lhs                   GHC.Types.RdrName
     119  Name.lhs/boot                 GHC.Types.Name
     120  NameEnv.lhs                   GHC.Types.Name.Env
     121  NameSet.lhs                   GHC.Types.Name.Set
     122  Literal.lhs                   GHC.Types.Literal
     123  Module.lhs/boot               GHC.Types.Module
    111124  NewDemand.lhs                 GHC.Types.Demand
    112   OccName.lhs/boot              GHC.Names.OccName
    113   RdrName.lhs                   GHC.Names.RdrName
    114   SrcLoc.lhs                    GHC.[Utils/Info].SrcLoc
    115   UniqSupply.lhs                GHC.Utils.Unique.Supply
    116   Unique.lhs                    GHC.Utils.Unique
    117   Var.lhs                       GHC.Names.Var
    118   VarEnv.lhs                    GHC.Names.Var.Env[ironment]
    119   VarSet.lhs                    GHC.Names.Var.Set
     125  SrcLoc.lhs                    GHC.Types.SrcLoc
     126  Unique.lhs                    GHC.Types.Unique
     127                                 -- if we can make it independent of GHC it
     128                                 -- could go into GHC.Utils
     129  UniqSupply.lhs                GHC.Types.Unique.Supply
    120130
    121131types/
    122   Class.lhs                     GHC.[Haskell.]Types.Class
    123   Coercion.lhs                  GHC.[Haskell.]Types.Coercion
    124   FamInstEnv.lhs                GHC.Typecheck.FamInstEnv -- ?
    125   FunDeps.lhs                   GHC.[Haskell.]Types.FunDeps
    126   Generics.lhs                  GHC.[Haskell.]Types.Generics -- !!
    127   InstEnv.lhs                   GHC.Typecheck.InstEnv -- ?
    128   TyCon.lhs/boot                GHC.[Haskell.]Types.TyCon
    129   Type.lhs                      GHC.[Haskell.]Types.Type
    130   TypeRep.lhs/boot              GHC.[Haskell.]Types.Type.Rep -- !!
    131   Unify.lhs                     GHC.Type.Unify -- ?
     132  Class.lhs                     GHC.Types.Class
     133  Coercion.lhs                  GHC.Types.Type.Coercion -- ?
     134  FamInstEnv.lhs                GHC.Types.FamInstEnv -- ?
     135  FunDeps.lhs                   GHC.Types.FunDeps
     136  Generics.lhs                  GHC.Types.Generics
     137  InstEnv.lhs                   GHC.Types.InstEnv -- ?
     138  TyCon.lhs/boot                GHC.Types.TyCon
     139  Type.lhs                      GHC.Types.Type
     140  TypeRep.lhs/boot              GHC.Types.Type.Rep
     141  Unify.lhs                     GHC.Types.Type.Unify -- ?
    132142
    133143hsSyn/
    134   Convert.lhs                   GHC.Haskell.Syntax.[TH/TemplateHaskell].Convert
    135   HsBinds.lhs                   GHC.Haskell.Syntax.Bind[er] -- what about sigs?
    136   HsDecls.lhs                   GHC.Haskell.Syntax.Declaration
    137   HsDoc.hs                      GHC.Haskell.Syntax.Documentation
    138   HsExpr.lhs/boot               GHC.Haskell.Syntax.Expression
    139   HsImpExp.lhs                  GHC.Haskell.Syntax.ImportExport
    140   HsLit.lhs                     GHC.Haskell.Syntax.Literal
    141   HsPat.lhs/boot                GHC.Haskell.Syntax.Pattern
    142   HsSyn.lhs                     GHC.Haskell.Syntax
    143   HsTypes.lhs                   GHC.Haskell.Syntax.Type
    144   HsUtils.lhs                   GHC.Haskell.Syntax.Utils
     144  Convert.lhs                   GHC.Syntax.[TH/TemplateHaskell].Convert
     145  HsBinds.lhs                   GHC.Syntax.Bind[er] -- what about sigs?
     146  HsDecls.lhs                   GHC.Syntax.Declaration
     147  HsDoc.hs                      GHC.Syntax.Documentation
     148  HsExpr.lhs/boot               GHC.Syntax.Expression
     149  HsImpExp.lhs                  GHC.Syntax.ImportExport
     150  HsLit.lhs                     GHC.Syntax.Literal
     151  HsPat.lhs/boot                GHC.Syntax.Pattern
     152  HsSyn.lhs                     GHC.Syntax
     153  HsTypes.lhs                   GHC.Syntax.Type
     154  HsUtils.lhs                   GHC.Syntax.Utils
    145155
    146156parser/
    147157  Ctype.lhs                     GHC.[Haskell.Parser.]Utils.ClassifyChar
    148158  HaddockLex.hs-boot
    149   HaddockLex.x                  Haddock.Lexer  -- can this clash with haddock itself?
    150   HaddockParse.y                Haddock.Parser -- ditto
    151   HaddockUtils.hs               Haddock.Parser.Utils -- ditto
    152   Lexer.x                       GHC.Haskell.Lexer
    153   Parser.y[.pp]                 GHC.Haskell.Parser
    154   RdrHsSyn.lhs                  GHC.Haskell.Parser.Syntax -- ?
    155   LexCore.hs                    GHC.Core.Lexer
    156   ParserCore.y                  GHC.Core.Parser
    157   ParserCoreUtils.hs            GHC.Core.Parser.Utils
     159  HaddockLex.x                  Haddock.Lex  -- can this clash with haddock itself?
     160  HaddockParse.y                Haddock.Parse -- ditto
     161  HaddockUtils.hs               Haddock.Parse.Utils -- ditto
     162  Lexer.x                       GHC.Parse.Lex
     163  Parser.y[.pp]                 GHC.Parse.Parse
     164  RdrHsSyn.lhs                  GHC.Parse.Syntax / GHC.Parse.Utils -- ?
     165  LexCore.hs                    GHC.Core.Lex
     166  ParserCore.y                  GHC.Core.Parse
     167  ParserCoreUtils.hs            GHC.Core.Parse.Utils
    158168  cutils.c
    159169  cutils.h
     
    161171
    162172typecheck/
    163   FamInst.lhs                   GHC.Typecheck.FamilyInstance
     173  FamInst.lhs                   GHC.Typecheck.FamInst
    164174  Inst.lhs                      GHC.Typecheck.Instance
    165175  TcArrows.lhs                  GHC.Typecheck.Arrows
    166176  TcBinds.lhs                   GHC.Typecheck.Binders
    167   TcClassDcl.lhs                GHC.Typecheck.ClassDeclaration
     177  TcClassDcl.lhs                GHC.Typecheck.ClassDecl
    168178  TcDefaults.lhs                GHC.Typecheck.Defaults
    169179  TcDeriv.lhs                   GHC.Typecheck.Deriving
    170   TcEnv.lhs/boot                GHC.Typecheck.Environment
    171   TcExpr.lhs/boot               GHC.Typecheck.Expression
    172   TcForeign.lhs                 GHC.Typecheck.Foreign
     180  TcEnv.lhs/boot                GHC.Typecheck.Env
    173181  TcGenDeriv.lhs                GHC.Typecheck.Deriving.Generate
    174   TcHsSyn.lhs                   GHC.Typecheck.Haskell.Syntax -- ?
    175   TcHsType.lhs                  GHC.Typecheck.Haskell.[Mono]Type -- ?
    176   TcInstDcls.lhs                GHC.Typecheck.InstanceDeclaration
    177   TcMType.lhs                   GHC.Typecheck.Monad.TypeOps
    178   TcMatches.lhs/boot            GHC.Typecheck.Matches
    179   TcPat.lhs                     GHC.Typecheck.Pattern
     182  TcExpr.lhs/boot               GHC.Typecheck.Syntax.Expr
     183  TcForeign.lhs                 GHC.Typecheck.Syntax.Foreign
     184  TcHsSyn.lhs                   GHC.Typecheck.Syntax -- ?
     185  TcHsType.lhs                  GHC.Typecheck.Syntax.[Mono]Type -- ?
     186  TcMatches.lhs/boot            GHC.Typecheck.Syntax.Matches
     187  TcPat.lhs                     GHC.Typecheck.Syntax.Pattern
     188  TcInstDcls.lhs                GHC.Typecheck.InstDecl
    180189  TcRnDriver.lhs                GHC.Typecheck[Rename].[Driver/Module]
    181190  TcRnMonad.lhs                 GHC.Typecheck[Rename].Monad
     191  TcMType.lhs                   GHC.Typecheck.Monad.TypeOps
    182192  TcRnTypes.lhs/boot            GHC.Typecheck.Types
    183193  TcRules.lhs                   GHC.Typecheck.Rules
    184   TcSimplify.lhs                -- ?
     194  TcSimplify.lhs                -- what does this do?
    185195  TcSplice.lhs/boot             GHC.Typecheck.Splice
    186196  TcTyClsDecls.lhs              GHC.Typecheck.TypeAndClassDeclaration
     
    188198  TcTyFuns.lhs                  GHC.Typecheck.TypeFunction
    189199  TcType.lhs/boot               GHC.Typecheck.Type
    190   TcUnify.lhs/boot              GHC.Typecheck.Unify
     200  TcUnify.lhs/boot              GHC.Typecheck.Unify -- difference to Unify?
    191201
    192202rename/
    193   RnBinds.lhs                   GHC.Rename.Bind[er]
    194   RnEnv.lhs                     GHC.Rename.Environment
    195   RnExpr.lhs/boot               GHC.Rename.Expression
    196   RnHsDoc.hs                    GHC.Rename.Haskell.Syntax.Documentation
    197   RnHsSyn.lhs                   GHC.Rename.Haskell.Syntax
    198   RnNames.lhs                   GHC.Rename.[Names/ImportsExports]
     203  RnBinds.lhs                   GHC.Rename.Bind
     204  RnEnv.lhs                     GHC.Rename.Env
     205  RnExpr.lhs/boot               GHC.Rename.Expr
     206  RnHsDoc.hs                    GHC.Rename.Docs
     207  RnHsSyn.lhs                   GHC.Rename.Syntax
     208  RnNames.lhs                   GHC.Rename.[Name/ImportExport]
    199209  RnPat.lhs                     GHC.Rename.Pattern
    200210  RnSource.lhs                  GHC.Rename.Main
     
    244254  LoadIface.lhs                 GHC.Interface.Load
    245255  MkIface.lhs                   GHC.Interface.Make
    246   TcIface.lhs/boot              GHC.Interface.Typecheck / GHC.Typecheck.Interface -- maybe both (i.e. re-export)?  seems to import only one Tc* module
     256  TcIface.lhs/boot              GHC.Interface.Typecheck / GHC.Typecheck.Interface
     257                                -- maybe both (i.e. re-export)?  seems to import only one Tc* module
    247258
    248259simplCore/
    249   SimplCore.lhs                 GHC.Core.Simplify
    250   SimplEnv.lhs                  GHC.Core.Simplify.Environment
    251   SimplMonad.lhs                GHC.Core.Simplify.Monad
    252   SimplUtils.lhs                GHC.Core.Simplify.Utils
    253   Simplify.lhs                  GHC.Core.Simplify.[Pass/Once/Step]
    254   CSE.lhs                       GHC.Core.Simplify.[CSE/CommonSubexprElim]
     260  SimplCore.lhs                 GHC.Core.Optimise
     261  SimplEnv.lhs                  GHC.Core.[Simplify.]Env
     262  SimplMonad.lhs                GHC.Core.[Simplify.]Monad
     263  SimplUtils.lhs                GHC.Core.[Simplify.]Utils
     264  Simplify.lhs                  GHC.Core.Simplify
     265  CSE.lhs                       GHC.Core.[CSE/CommonSubexprElim]
    255266  SAT.lhs                       GHC.Core.Simplify.[StaticArgTrans/StaticArgumentTransformation]
    256   FloatIn.lhs                   GHC.Core.Simplify.FloatIn
    257   FloatOut.lhs                  GHC.Core.Simplify.FloatOut
    258   SetLevels.lhs                 GHC.Core.Simplify.FloatOut.SetLevels
    259   LiberateCase.lhs              GHC.Core.Simplify.LiberateCase
    260   OccurAnal.lhs                 GHC.Core.OccurenceAnalysis -- used by SimplCore, CoreUnfold, DsBinds, Rules
     267  FloatIn.lhs                   GHC.Core.FloatIn
     268  FloatOut.lhs                  GHC.Core.FloatOut
     269  SetLevels.lhs                 GHC.Core.FloatOut.SetLevels
     270  LiberateCase.lhs              GHC.Core.LiberateCase
     271  OccurAnal.lhs                 GHC.Core.OccAnalysis -- used by SimplCore, CoreUnfold, DsBinds, Rules
    261272  simplifier.tib               
    262273
     
    292303
    293304simplStg/
    294   SRT.lhs                       GHC.STG.Simplify.StaticReferenceTable
    295   SimplStg.lhs                  GHC.STG.Simplify
    296   StgStats.lhs                  GHC.STG.Simplify.Stats
     305  SRT.lhs                       GHC.STG.StaticRefTable
     306  SimplStg.lhs                  GHC.STG.Optimise
     307  StgStats.lhs                  GHC.STG.[Optimise.]Stats
    297308
    298309profiling/
    299   CostCentre.lhs                GHC.Types[.Profiling].CostCentre
     310  CostCentre.lhs                GHC.Types.CostCentre
    300311  NOTES                         -- merge into haddocks somewhere? (where?)
    301   SCCfinal.lhs                  GHC.STG.Simplify.SCCFinal -- better name? (called only by SimplStg)
    302 
    303 -- alternatively: GHC.BuiltIn.*
     312  SCCfinal.lhs                  GHC.STG.Simplify.SCCFinal / GHC.STG.Profiling
     313
     314-- pretty messy stuff
    304315prelude/
    305   ForeignCall.lhs               GHC.Prelude.ForeignCalls -- is this just a bunch of types?
    306   PrelInfo.lhs                  GHC.Prelude.Info
    307   PrelNames.lhs                 GHC.Prelude.Names
    308   PrelRules.lhs                 GHC.Prelude.Rules
    309   PrimOp.lhs                    GHC.Prelude.PrimOps
    310   TysPrim.lhs                   GHC.Prelude.PrimTypes
    311   TysWiredIn.lhs                GHC.Prelude.WiredInTypeKnowledge -- ?
    312   primops.txt[.pp]              -- still used?
     316  ForeignCall.lhs               GHC.Types.ForeignCall
     317  PrelInfo.lhs                  -- put into other files
     318  PrelNames.lhs                 GHC.Builtin.Names
     319  PrelRules.lhs                 GHC.Builtin.Rules
     320  PrimOp.lhs                    GHC.Builtin.Prim.PrimOps
     321  TysPrim.lhs                   GHC.Builtin.Prim.Types
     322  TysWiredIn.lhs                GHC.Builtin.Types / GHC.Builtin.Prim.Rules ?
     323                                  -- this module contains wired-in *knowledge* about types, really
     324  primops.txt[.pp]              -- put where?
    313325
    314326