Changed all the lists of passes to add pre- and post- properties

backends/GenerateC.hs

@@ -17,7 +17,7 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 -}
 
 -- | Generate C code from the mangled AST.
-module GenerateC (cgenOps, cintroduceSpec, fget, genComma, genCPasses, generate, generateC, genLeftB, genMeta, genName, genRightB, GenOps(..), indexOfFreeDimensions, seqComma, withIf ) where
+module GenerateC (cgenOps, cintroduceSpec, cPreReq, fget, genComma, genCPasses, generate, generateC, genLeftB, genMeta, genName, genRightB, GenOps(..), indexOfFreeDimensions, seqComma, withIf ) where
 
 import Data.Char
 import Data.Generics
@@ -39,6 +39,7 @@ import EvalLiterals
 import GenerateCBased
 import Metadata
 import Pass
+import qualified Properties as Prop
 import ShowCode
 import TLP
 import Types
@@ -46,12 +47,15 @@ import Utils
 
 --{{{  passes related to C generation
 genCPasses :: [Pass]
-genCPasses = makePasses' ((== BackendC) . csBackend)
+genCPasses = makePassesDep' ((== BackendC) . csBackend)
-  [ ("Identify parallel processes", identifyParProcs)
+  [ ("Identify parallel processes", identifyParProcs, [Prop.parsWrapped], [])
-   ,("Transform wait for guards into wait until guards", transformWaitFor)
+   ,("Transform wait for guards into wait until guards", transformWaitFor, [], [Prop.waitForRemoved])
   ]
 --}}}
 
+cPreReq :: [Property]
+cPreReq = cCppCommonPreReq ++ [Prop.parsIdentified, Prop.waitForRemoved]
+
 -- | Operations for the C backend.
 cgenOps :: GenOps
 cgenOps = GenOps {

backends/GenerateCBased.hs

@@ -29,8 +29,29 @@ import CompState
 import Errors
 import Metadata
 import Pass
+import qualified Properties as Prop
 import TLP
 
+cCppCommonPreReq :: [Property]
+cCppCommonPreReq =
+ [Prop.afterRemoved
+ ,Prop.arrayLiteralsExpanded
+ ,Prop.assignFlattened
+ ,Prop.assignParRemoved
+ ,Prop.freeNamesToArgs
+ ,Prop.functionCallsRemoved
+ ,Prop.functionsRemoved
+ ,Prop.inputCaseRemoved
+ ,Prop.mainTagged
+ ,Prop.nestedPulled
+ ,Prop.outExpressionRemoved
+ ,Prop.parsWrapped
+ ,Prop.parUsageChecked
+ ,Prop.subscriptsPulledUp
+ ,Prop.typesResolvedInAST
+ ,Prop.typesResolvedInState
+ ]
+
 
 --{{{  monad definition
 type CGen' = WriterT [String] PassM

backends/GenerateCPPCSP.hs

@@ -68,7 +68,7 @@ as well.  May be worth changing in future.
 Channels of direction 'A.DirUnknown' are passed around as pointers to a One2OneChannel\<\> object.  To read I use the reader() function and to write I use the writer() function.
 For channels of direction 'A.DirInput' or 'A.DirOutput' I actually pass the Chanin\<\> and Chanout\<\> objects as you would expect.
 -}
-module GenerateCPPCSP (generateCPPCSP, cppgenOps, genCPPCSPPasses) where
+module GenerateCPPCSP (cppcspPrereq, cppgenOps, generateCPPCSP, genCPPCSPPasses) where
 
 import Control.Monad.State
 import Control.Monad.Writer
@@ -84,6 +84,7 @@ import GenerateC
 import GenerateCBased
 import Metadata
 import Pass
+import qualified Properties as Prop
 import ShowCode
 import TLP
 import Types
@@ -134,8 +135,8 @@ cppgenOps = cgenOps {
 --}}}
 
 genCPPCSPPasses :: [Pass]
-genCPPCSPPasses = makePasses' ((== BackendCPPCSP) . csBackend)
+genCPPCSPPasses = makePassesDep' ((== BackendCPPCSP) . csBackend)
-  [ ("Transform channels to ANY", chansToAny)
+  [ ("Transform channels to ANY", chansToAny, [Prop.processTypesChecked], [Prop.allChansToAnyOrProtocol])
   ]
 
 chansToAny :: Data t => t -> PassM t
@@ -162,6 +163,10 @@ chansToAny x = do st <- get
 generateCPPCSP :: A.AST -> PassM String
 generateCPPCSP = generate cppgenOps
 
+cppcspPrereq :: [Property]
+cppcspPrereq = cCppCommonPreReq ++ [Prop.allChansToAnyOrProtocol]
+ 
+
 -- | Generates the top-level code for an AST.
 cppgenTopLevel :: A.AST -> CGen ()
 cppgenTopLevel s

common/PassList.hs

@@ -43,11 +43,17 @@ import Utils
 commonPasses :: CompState -> [Pass]
 commonPasses opts = concat $
   [ simplifyTypes
-  , makePasses' csUsageChecking [("Usage checking", runPassR usageCheckPass)]
+  , makePassesDep' csUsageChecking [("Usage checking", runPassR usageCheckPass, Prop.agg_namesDone, [Prop.parUsageChecked])]
+  -- If usage checking is turned off, the pass list will break unless we insert this dummy item:
+  , makePassesDep' (not . csUsageChecking) [("Usage checking turned OFF", return, Prop.agg_namesDone, [Prop.parUsageChecked])]
   , simplifyExprs
   , simplifyProcs
   , unnest
   , simplifyComms
+  -- The occam frontend does a lot of work for us, so I represent that here:
+  ,makePassesDep' ((== FrontendOccam) . csFrontend) [("Null occam pass", return, [],
+    Prop.agg_namesDone ++ [Prop.constantsFolded, Prop.expressionTypesChecked, Prop.inferredTypesRecorded, Prop.mainTagged, Prop.processTypesChecked]
+  )]
   ]
 
 filterPasses :: CompState -> [Pass] -> [Pass]

frontends/RainPasses.hs

@@ -30,42 +30,46 @@ import Errors
 import Metadata
 import Pass
 import Pattern
+import qualified Properties as Prop
 import RainTypes
 import TreeUtils
 import Types
 
+
 -- | An ordered list of the Rain-specific passes to be run.
 rainPasses :: [Pass]
-rainPasses = makePasses' ((== FrontendRain) . csFrontend)
+rainPasses = makePassesDep' ((== FrontendRain) . csFrontend)
-     [ ("AST Validity check, Rain #1", excludeNonRainFeatures)
+     [ ("AST Validity check, Rain #1", excludeNonRainFeatures, [], []) -- TODO work out some dependencies
-       ,("Resolve Int -> Int64",transformInt)
+       ,("Resolve Int -> Int64", transformInt, [], [Prop.noInt])
-       ,("Uniquify variable declarations, record declared types and resolve variable names",uniquifyAndResolveVars) --depends on transformInt
+       ,("Uniquify variable declarations, record declared types and resolve variable names",
+           uniquifyAndResolveVars, [Prop.noInt], namesDone)
+            
+       ,("Fold all constant expressions", constantFoldPass, [Prop.noInt] ++ namesDone, [Prop.constantsFolded])
+       ,("Annotate integer literal types", annnotateIntLiteralTypes, [Prop.noInt] ++ namesDone, [Prop.intLiteralsInBounds])
        
-       ,("Fold all constant expressions",constantFoldPass) -- depends on transformInt and possibly depends on uniquifyAndResolveVars, not sure
+       ,("Record inferred name types in dictionary", recordInfNameTypes, namesDone ++ [Prop.intLiteralsInBounds], [Prop.inferredTypesRecorded])
-       ,("Annotate integer literal types",annnotateIntLiteralTypes) --depends on transformInt and constantFoldPass
        
-       ,("Record inferred name types in dictionary",recordInfNameTypes) --depends on uniquifyAndResolveVars and annnotateIntLiteralTypes
+       ,("Check types in expressions",checkExpressionTypes, namesDone ++ [Prop.noInt, Prop.constantsFolded, Prop.intLiteralsInBounds, Prop.inferredTypesRecorded], [Prop.expressionTypesChecked]) 
+       ,("Check types in assignments", checkAssignmentTypes, typesDone ++ [Prop.expressionTypesChecked], [Prop.processTypesChecked])
+       ,("Check types in if/while conditions",checkConditionalTypes, typesDone ++ [Prop.expressionTypesChecked], [Prop.processTypesChecked])
+       ,("Check types in input/output",checkCommTypes, typesDone ++ [Prop.expressionTypesChecked], [Prop.processTypesChecked])
+       ,("Check types in now statements",checkGetTimeTypes, typesDone, [Prop.processTypesChecked])
+       ,("Check parameters in process calls", matchParamPass, typesDone, [Prop.processTypesChecked])
        
-       ,("Check types in expressions",checkExpressionTypes) 
+       ,("Find and tag the main function", findMain, namesDone, [Prop.mainTagged])
-           --depends on transformInt, uniquifyAndResolveVars, constantFoldPass, annnotateIntLiteralTypes, recordInfNameTypes
+       ,("Convert seqeach/pareach loops over ranges into simple replicated SEQ/PAR",transformEachRange, typesDone, [Prop.eachRangeTransformed])
-       ,("Check types in assignments",checkAssignmentTypes) --depends on uniquifyAndResolveVars, recordInfNameTypes, checkExpressionTypes
+       ,("Convert seqeach/pareach loops into classic replicated SEQ/PAR",transformEach, typesDone ++ [Prop.eachRangeTransformed], [Prop.eachTransformed])
-       ,("Check types in if/while conditions",checkConditionalTypes) --depends on uniquifyAndResolveVars, recordInfNameTypes, checkExpressionTypes
+       ,("Convert simple Rain range constructors into more general array constructors",transformRangeRep, typesDone ++ [Prop.eachRangeTransformed], [Prop.rangeTransformed])
-       ,("Check types in input/output",checkCommTypes) --depends on uniquifyAndResolveVars, recordInfNameTypes, checkExpressionTypes
+       ,("Transform Rain functions into the occam form",transformFunction, typesDone ++ [Prop.eachTransformed], []) -- TODO need to sort out functions anyway
-       ,("Check types in now statements",checkGetTimeTypes) --depends on uniquifyAndResolveVars, recordInfNameTypes
+       ,("Pull up par declarations", pullUpParDeclarations, [], [Prop.rainParDeclarationsPulledUp])
-       
-       ,("Find and tag the main function",findMain) --depends on uniquifyAndResolveVars
-       ,("Check parameters in process calls",matchParamPass) --depends on uniquifyAndResolveVars and recordInfNameTypes and checkExpressionTypes
-       ,("Convert seqeach/pareach loops over ranges into simple replicated SEQ/PAR",transformEachRange)
-         --depends on uniquifyAndResolveVars and recordInfNameTypes       
-       ,("Convert seqeach/pareach loops into classic replicated SEQ/PAR",transformEach) 
-         --depends on uniquifyAndResolveVars and recordInfNameTypes, and should be done after transformEachRange
-       ,("Convert simple Rain range constructors into more general array constructors",transformRangeRep)
-         --must be done after transformEachRange
-       ,("Transform Rain functions into the occam form",transformFunction)
-         --must be done after transformEach, depends on uniquifyAndResolveVars and recordInfNameTypes
-       ,("Pull up par declarations", pullUpParDeclarations) --doesn't depend on anything
-       ,("AST Validity check, Rain #2", (\x -> excludeNonRainFeatures x >>= excludeTransformedRainFeatures))
      ]
+  where
+    namesDone :: [Property]
+    namesDone = [Prop.declaredNamesResolved, Prop.declarationTypesRecorded, Prop.declarationsUnique]
+
+    typesDone :: [Property]
+    typesDone = namesDone ++ [Prop.inferredTypesRecorded]
+
 
 -- | A pass that transforms all instances of 'A.Int' into 'A.Int64'
 transformInt :: Data t => t -> PassM t
@@ -282,15 +286,6 @@ pullUpParDeclarations = everywhereM (mkM pullUpParDeclarations')
           Just (trans,inner') -> Just ( (A.Spec m spec) . trans,inner')
     chaseSpecs _ = Nothing
 
--- | All the items that should have been removed at the end of the Rain passes.
-excludeTransformedRainFeatures :: (Data t, CSMR m) => t -> m t
-excludeTransformedRainFeatures = excludeConstr
-  [ con0 A.Int
-   ,con0 A.Any
-   ,con3 A.RangeConstr
-   ,con3 A.ForEach
-  ]
-
 -- | All the items that should not occur in an AST that comes from Rain (up until it goes into the shared passes).
 excludeNonRainFeatures :: (Data t, CSMR m) => t -> m t
 excludeNonRainFeatures = excludeConstr

transformations/SimplifyComms.hs

@@ -27,13 +27,14 @@ import qualified AST as A
 import CompState
 import Metadata
 import Pass
+import qualified Properties as Prop
 import Types
 import Utils
 
 simplifyComms :: [Pass]
-simplifyComms = makePasses
+simplifyComms = makePassesDep
-      [ ("Define temporary variables for outputting expressions", outExprs)
+      [ ("Define temporary variables for outputting expressions", outExprs, Prop.agg_namesDone ++ Prop.agg_typesDone, [Prop.outExpressionRemoved])
-       ,("Transform ? CASE statements/guards into plain CASE", transformInputCase)
+       ,("Transform ? CASE statements/guards into plain CASE", transformInputCase, Prop.agg_namesDone ++ Prop.agg_typesDone, [Prop.inputCaseRemoved])
       ]
 
 outExprs :: Data t => t -> PassM t

transformations/SimplifyExprs.hs

@@ -28,15 +28,16 @@ import CompState
 import Errors
 import Metadata
 import Pass
+import qualified Properties as Prop
 import Types
 
 simplifyExprs :: [Pass]
-simplifyExprs = makePasses
+simplifyExprs = makePassesDep
-      [ ("Convert FUNCTIONs to PROCs", functionsToProcs)
+      [ ("Convert FUNCTIONs to PROCs", functionsToProcs, Prop.agg_namesDone ++ [Prop.parUsageChecked], [Prop.functionsRemoved])
-      , ("Convert AFTER to MINUS", removeAfter)
+      , ("Convert AFTER to MINUS", removeAfter, [Prop.expressionTypesChecked], [Prop.afterRemoved])
-      , ("Expand array literals", expandArrayLiterals)
+      , ("Expand array literals", expandArrayLiterals, [Prop.expressionTypesChecked, Prop.processTypesChecked], [Prop.arrayLiteralsExpanded])
-      , ("Pull up definitions", pullUp)
+      , ("Pull up definitions", pullUp, Prop.agg_namesDone ++ [Prop.expressionTypesChecked, Prop.functionsRemoved, Prop.processTypesChecked], [Prop.functionCallsRemoved, Prop.subscriptsPulledUp])
-      , ("Transform array constructors into initialisation code", transformConstr)
+      , ("Transform array constructors into initialisation code", transformConstr, Prop.agg_namesDone ++ Prop.agg_typesDone, [])
       ]
 
 -- | Convert FUNCTION declarations to PROCs.

transformations/SimplifyProcs.hs

@@ -25,14 +25,15 @@ import Data.Generics
 import qualified AST as A
 import CompState
 import Metadata
-import Types
 import Pass
+import qualified Properties as Prop
+import Types
 
 simplifyProcs :: [Pass]
-simplifyProcs = makePasses
+simplifyProcs = makePassesDep
-      [ ("Wrap PAR subprocesses in PROCs", parsToProcs)
+      [ ("Wrap PAR subprocesses in PROCs", parsToProcs, [Prop.parUsageChecked], [Prop.parsWrapped])
-      , ("Remove parallel assignment", removeParAssign)
+      , ("Remove parallel assignment", removeParAssign, [Prop.parUsageChecked], [Prop.assignParRemoved])
-      , ("Flatten assignment", flattenAssign)
+      , ("Flatten assignment", flattenAssign, [Prop.assignParRemoved], [Prop.assignFlattened])
       ]
 
 -- | Wrap the subprocesses of PARs in no-arg PROCs.

transformations/SimplifyTypes.hs

@@ -25,12 +25,13 @@ import Data.Generics
 import qualified AST as A
 import Metadata
 import Pass
+import qualified Properties as Prop
 import Types
 
 simplifyTypes :: [Pass]
-simplifyTypes = makePasses
+simplifyTypes = makePassesDep
-      [ ("Resolve types in AST", resolveNamedTypes)
+      [ ("Resolve types in AST", resolveNamedTypes, Prop.agg_namesDone, [Prop.typesResolvedInAST])
-      , ("Resolve types in state", rntState)
+      , ("Resolve types in state", rntState, Prop.agg_namesDone, [Prop.typesResolvedInState])
       ]
 
 -- | Turn named data types into their underlying types.

transformations/Unnest.hs

@@ -30,12 +30,13 @@ import Errors
 import EvalConstants
 import Metadata
 import Pass
+import qualified Properties as Prop
 import Types
 
 unnest :: [Pass]
-unnest = makePasses
+unnest = makePassesDep
-      [ ("Convert free names to arguments", removeFreeNames)
+      [ ("Convert free names to arguments", removeFreeNames, [Prop.mainTagged, Prop.parsWrapped], [Prop.freeNamesToArgs])
-      , ("Pull nested definitions to top level", removeNesting)
+      , ("Pull nested definitions to top level", removeNesting, [Prop.freeNamesToArgs], [Prop.nestedPulled])
       ]
 
 type NameMap = Map.Map String A.Name