Move ResumeKind to separate module to fix dependencies

Jakefile.js

@@ -380,6 +380,7 @@ var hsModules = [
   "Common.Message",
   "Common.Unique",
   "Common.Error",
+  "Common.ResumeKind",
 
   "Syntax.Lexeme",
   alexModule("Syntax.Lexer"),

src/Common/ResumeKind.hs

@@ -0,0 +1,34 @@
+-----------------------------------------------------------------------------
+-- Copyright 2018 Microsoft Corporation.
+--
+-- This is free software; you can redistribute it and/or modify it under the
+-- terms of the Apache License, Version 2.0. A copy of the License can be
+-- found in the file "license.txt" at the root of this distribution.
+-----------------------------------------------------------------------------
+{-
+    Kinds describing how an operation is using the resumption.
+-}
+-----------------------------------------------------------------------------
+module Common.ResumeKind ( ResumeKind(..) ) where
+
+data ResumeKind
+  = ResumeNever
+  | ResumeTail
+  | ResumeScopedOnce
+  | ResumeScoped
+  | ResumeOnce
+  | ResumeNormal
+  | ResumeOnceRaw
+  | ResumeNormalRaw
+  deriving (Eq,Ord,Enum)
+
+instance Show ResumeKind where
+  show rk = case rk of
+              ResumeNever -> "never"
+              ResumeTail  -> "tail"
+              ResumeScopedOnce -> "scoped once"
+              ResumeScoped -> "scoped"
+              ResumeOnce  -> "once"
+              ResumeNormal -> "normal"
+              ResumeOnceRaw -> "once (no finalization)"
+              ResumeNormalRaw -> "normal (no finalization)"

src/Core/AnalysisResume.hs

@@ -9,7 +9,7 @@
 -}
 -----------------------------------------------------------------------------
 
-module Core.AnalysisResume( ResumeKind(..), analyzeResume ) where
+module Core.AnalysisResume( analyzeResume ) where
 
 
 import Lib.Trace
@@ -22,35 +22,14 @@ import Common.Range
 import Common.Failure
 import Common.Unique()
 import Common.NamePrim( namePatternMatchError, nameSystemCore )
+import Common.ResumeKind( ResumeKind(..) )
 import Kind.Kind( kindStar )
 import Type.Type
 import Type.Pretty (defaultEnv)
 import Core.Core
 import Core.CoreVar
 import Core.Pretty
 
-data ResumeKind
-  = ResumeNever
-  | ResumeTail
-  | ResumeScopedOnce
-  | ResumeScoped
-  | ResumeOnce
-  | ResumeNormal
-  | ResumeOnceRaw
-  | ResumeNormalRaw
-  deriving (Eq,Ord,Enum)
-
-instance Show ResumeKind where
-  show rk = case rk of
-              ResumeNever -> "never"
-              ResumeTail  -> "tail"
-              ResumeScopedOnce -> "scoped once"
-              ResumeScoped -> "scoped"
-              ResumeOnce  -> "once"
-              ResumeNormal -> "normal"
-              ResumeOnceRaw -> "once (no finalization)"
-              ResumeNormalRaw -> "normal (no finalization)"
-
 analyzeResume :: Name -> Name -> Bool -> Expr -> ResumeKind
 analyzeResume defName opName raw expr
   = case expr of

src/Syntax/Parse.hs

@@ -50,15 +50,14 @@ import Platform.Config
 import Platform.Runtime( unsafePerformIO, exCatch )
 import Common.Error
 import Common.Syntax
+import Common.ResumeKind
 
 import Syntax.Syntax
 import Syntax.Lexeme
 import Syntax.Lexer   ( lexing )
 import Syntax.Layout  ( layout )
 import Syntax.Promote ( promote, promoteType, quantify, promoteFree )
 
-import Core.AnalysisResume( ResumeKind(..) )
-
 -----------------------------------------------------------
 -- Parser on token stream
 -----------------------------------------------------------

src/Syntax/Syntax.hs

@@ -15,10 +15,11 @@ import Common.NamePrim( nameTrue, nameSystemCore )
 import Common.Name
 import Common.Range
 import Common.Failure( failure )
+import Common.ResumeKind
 import Common.Syntax
 import qualified Common.NameSet as S
 
-import Core.AnalysisResume( ResumeKind(..) )
+
 
 -- | A program
 data Program t k

src/Type/Infer.hs

@@ -60,8 +60,8 @@ import Type.InferMonad
 
 import qualified Core.CoreVar as CoreVar
 import Core.AnalysisMatch( analyzeBranches )
-import Core.AnalysisResume( analyzeResume, ResumeKind(..) )
-
+import Common.ResumeKind
+import Core.AnalysisResume
 import Core.Divergent( analyzeDivergence )
 import Core.BindingGroups( regroup )
 import Core.Simplify( uniqueSimplify )