Changes between Version 1 and Version 2 of ModuleDependencies/Hierarchical


Ignore:
Timestamp:
Oct 27, 2008 1:06:13 PM (5 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