← Back to branch summary

~ubuntu-branches/ubuntu/wily/agda/wily-proposed

« back to all changes in this revision

Viewing changes to src/full/Agda/TypeChecking/Monad/Imports.hs

  • Committer: Package Import Robot
  • Author(s): Iain Lane, d5cf60f
  • Date: 2015-05-20 13:08:33 UTC
  • mfrom: (1.1.7)
  • Revision ID: package-import@ubuntu.com-20150520130833-cdcmhagwsouna237
Tags: 2.4.2.2-2
[d5cf60f] Depend on ${shlibs:Depends}, to get libc (& maybe other) deps

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/full/Agda/TypeChecking/Monad/Imports.hs
1
 
 
2
1
module Agda.TypeChecking.Monad.Imports where
3
2
 
4
3
import Control.Monad.State
11
10
import Agda.Syntax.Abstract.Name
12
11
import qualified Agda.Syntax.Concrete.Name as C
13
12
import Agda.TypeChecking.Monad.Base
 
13
import Agda.Utils.Lens
14
14
import Agda.Utils.Monad
15
15
import Agda.Utils.Time
16
16
import Agda.Utils.Hash
17
17
 
18
18
addImport :: ModuleName -> TCM ()
19
19
addImport m =
20
 
    modify $ \s -> s { stImportedModules = Set.insert m $ stImportedModules s }
 
20
    stImportedModules %= Set.insert m
21
21
 
22
22
addImportCycleCheck :: C.TopLevelModuleName -> TCM a -> TCM a
23
23
addImportCycleCheck m =
24
24
    local $ \e -> e { envImportPath = m : envImportPath e }
25
25
 
26
26
getImports :: TCM (Set ModuleName)
27
 
getImports = gets stImportedModules
 
27
getImports = use stImportedModules
28
28
 
29
29
isImported :: ModuleName -> TCM Bool
30
30
isImported m = Set.member m <$> getImports
33
33
getImportPath = asks envImportPath
34
34
 
35
35
visitModule :: ModuleInfo -> TCM ()
36
 
visitModule mi = modify $ \s ->
37
 
  s { stVisitedModules =
38
 
        Map.insert (toTopLevelModuleName $ iModuleName $ miInterface mi)
39
 
                   mi $
40
 
          stVisitedModules s }
 
36
visitModule mi =
 
37
  stVisitedModules %=
 
38
    Map.insert (toTopLevelModuleName $ iModuleName $ miInterface mi) mi
41
39
 
42
40
setVisitedModules :: VisitedModules -> TCM ()
43
 
setVisitedModules ms = modify $ \s -> s { stVisitedModules = ms }
 
41
setVisitedModules ms = stVisitedModules .= ms
44
42
 
45
43
getVisitedModules :: TCM VisitedModules
46
 
getVisitedModules = gets stVisitedModules
 
44
getVisitedModules = use stVisitedModules
47
45
 
48
46
isVisited :: C.TopLevelModuleName -> TCM Bool
49
 
isVisited x = gets $ Map.member x . stVisitedModules
 
47
isVisited x = Map.member x <$> use stVisitedModules
50
48
 
51
49
getVisitedModule :: C.TopLevelModuleName
52
50
                 -> TCM (Maybe ModuleInfo)
53
 
getVisitedModule x = gets $ Map.lookup x . stVisitedModules
 
51
getVisitedModule x = Map.lookup x <$> use stVisitedModules
54
52
 
55
53
getDecodedModules :: TCM DecodedModules
56
 
getDecodedModules = stDecodedModules . stPersistent <$> get
 
54
getDecodedModules = stDecodedModules . stPersistentState <$> get
57
55
 
58
56
setDecodedModules :: DecodedModules -> TCM ()
59
57
setDecodedModules ms = modify $ \s ->
60
 
  s { stPersistent = (stPersistent s) { stDecodedModules = ms } }
 
58
  s { stPersistentState = (stPersistentState s) { stDecodedModules = ms } }
61
59
 
62
60
getDecodedModule :: C.TopLevelModuleName -> TCM (Maybe Interface)
63
 
getDecodedModule x = Map.lookup x . stDecodedModules . stPersistent <$> get
 
61
getDecodedModule x = Map.lookup x . stDecodedModules . stPersistentState <$> get
64
62
 
65
63
storeDecodedModule :: Interface -> TCM ()
66
64
storeDecodedModule i = modify $ \s ->
67
 
  s { stPersistent =
68
 
        (stPersistent s) { stDecodedModules =
 
65
  s { stPersistentState =
 
66
        (stPersistentState s) { stDecodedModules =
69
67
          Map.insert (toTopLevelModuleName $ iModuleName i) i $
70
 
            (stDecodedModules $ stPersistent s)
 
68
            (stDecodedModules $ stPersistentState s)
71
69
        }
72
70
  }
73
71
 
74
72
dropDecodedModule :: C.TopLevelModuleName -> TCM ()
75
73
dropDecodedModule x = modify $ \s ->
76
 
  s { stPersistent = (stPersistent s) { stDecodedModules =
77
 
                       Map.delete x $ stDecodedModules $ stPersistent s
78
 
                     }
 
74
  s { stPersistentState =
 
75
        (stPersistentState s) { stDecodedModules =
 
76
                                  Map.delete x $ stDecodedModules $ stPersistentState s
 
77
                              }
79
78
  }
80
79
 
81
80
withImportPath :: [C.TopLevelModuleName] -> TCM a -> TCM a
87
86
checkForImportCycle = do
88
87
    m:ms <- getImportPath
89
88
    when (m `elem` ms) $ typeError $ CyclicModuleDependency
90
 
                                   $ dropWhile (/= m) $ reverse (m:ms)
 
89
                                   $ dropWhile (/= m) $ reverse (m:ms)