replace Cmm 'hint' with 'kind'

C-- no longer has 'hints'; to guide parameter passing, it
has 'kinds'.  Renamed type constructor, data constructor, and record
fields accordingly

12 files changed, 63 insertions, 63 deletions

diff --git a/compiler/cmm/Cmm.hs b/compiler/cmm/Cmm.hs
index 3fd5e441a6..53a6d0addf 100644
--- a/compiler/cmm/Cmm.hs
+++ b/compiler/cmm/Cmm.hs
@@ -18,7 +18,7 @@ module Cmm (
         CmmReturnInfo(..),
 	CmmStmt(..), CmmActual, CmmActuals, CmmFormal, CmmFormals, CmmKind,
         CmmFormalsWithoutKinds, CmmFormalWithoutKind,
-        CmmHinted(..),
+        CmmKinded(..),
         CmmSafety(..),
 	CmmCallTarget(..),
 	CmmStatic(..), Section(..),
@@ -241,10 +241,10 @@ data CmmStmt
       CmmActuals         -- with these return values.
 
 type CmmKind   = MachHint
-data CmmHinted a = CmmHinted { hintlessCmm :: a, cmmHint :: CmmKind }
+data CmmKinded a = CmmKinded { kindlessCmm :: a, cmmKind :: CmmKind }
                          deriving (Eq)
-type CmmActual = CmmHinted CmmExpr
-type CmmFormal = CmmHinted LocalReg
+type CmmActual = CmmKinded CmmExpr
+type CmmFormal = CmmKinded LocalReg
 type CmmActuals = [CmmActual]
 type CmmFormals = [CmmFormal]
 type CmmFormalWithoutKind   = LocalReg
@@ -253,8 +253,8 @@ type CmmFormalsWithoutKinds = [CmmFormalWithoutKind]
 data CmmSafety      = CmmUnsafe | CmmSafe C_SRT
 
 -- | enable us to fold used registers over 'CmmActuals' and 'CmmFormals'
-instance UserOfLocalRegs a => UserOfLocalRegs (CmmHinted a) where
-  foldRegsUsed f set (CmmHinted a _) = foldRegsUsed f set a
+instance UserOfLocalRegs a => UserOfLocalRegs (CmmKinded a) where
+  foldRegsUsed f set (CmmKinded a _) = foldRegsUsed f set a
 
 instance UserOfLocalRegs CmmStmt where
   foldRegsUsed f set s = stmt s set
@@ -276,8 +276,8 @@ instance UserOfLocalRegs CmmCallTarget where
 
 --just look like a tuple, since it was a tuple before
 -- ... is that a good idea? --Isaac Dupree
-instance (Outputable a) => Outputable (CmmHinted a) where
-  ppr (CmmHinted a k) = ppr (a, k)
+instance (Outputable a) => Outputable (CmmKinded a) where
+  ppr (CmmKinded a k) = ppr (a, k)
 
 {-
 Discussion
diff --git a/compiler/cmm/CmmBrokenBlock.hs b/compiler/cmm/CmmBrokenBlock.hs
index 20a4a8c85e..526bdc1dd1 100644
--- a/compiler/cmm/CmmBrokenBlock.hs
+++ b/compiler/cmm/CmmBrokenBlock.hs
@@ -348,7 +348,7 @@ makeContinuationEntries formats
     case lookup ident formats of
       Nothing -> block
       Just (ContFormat formals srt is_gc) ->
-          BrokenBlock ident (ContinuationEntry (map hintlessCmm formals) srt is_gc)
+          BrokenBlock ident (ContinuationEntry (map kindlessCmm formals) srt is_gc)
                       stmts targets exit
 
 adaptBlockToFormat :: [(BlockId, ContFormat)]
@@ -378,7 +378,7 @@ adaptBlockToFormat formats unique
                        target formals actuals srt ret is_gc
 
       adaptor_block = mk_adaptor_block adaptor_ident
-                  (ContinuationEntry (map hintlessCmm formals) srt is_gc)
+                  (ContinuationEntry (map kindlessCmm formals) srt is_gc)
                   next format_formals
       adaptor_ident = BlockId unique
 
@@ -390,8 +390,8 @@ adaptBlockToFormat formats unique
                          (CmmLit (CmmLabel (mkReturnPtLabel (getUnique next))))
                          (map formal_to_actual format_formals)
 
-                formal_to_actual (CmmHinted reg hint)
-                     = (CmmHinted (CmmReg (CmmLocal reg)) hint)
+                formal_to_actual (CmmKinded reg hint)
+                     = (CmmKinded (CmmReg (CmmLocal reg)) hint)
                 -- TODO: Check if NoHint is right.  We're
                 -- jumping to a C-- function not a foreign one
                 -- so it might always be right.
diff --git a/compiler/cmm/CmmCPS.hs b/compiler/cmm/CmmCPS.hs
index 5a7998192b..a8adfb8e10 100644
--- a/compiler/cmm/CmmCPS.hs
+++ b/compiler/cmm/CmmCPS.hs
@@ -359,14 +359,14 @@ continuationMaxStack formats (Continuation _ label _ False blocks) =
                    map stmt_arg_size (brokenBlockStmts block))
 
       final_arg_size (FinalReturn args) =
-          argumentsSize (cmmExprRep . hintlessCmm) args
+          argumentsSize (cmmExprRep . kindlessCmm) args
       final_arg_size (FinalJump _ args) =
-          argumentsSize (cmmExprRep . hintlessCmm) args
+          argumentsSize (cmmExprRep . kindlessCmm) args
       final_arg_size (FinalCall next _ _ args _ _ True) = 0
       final_arg_size (FinalCall next _ _ args _ _ False) =
           -- We have to account for the stack used when we build a frame
           -- for the *next* continuation from *this* continuation
-          argumentsSize (cmmExprRep . hintlessCmm) args +
+          argumentsSize (cmmExprRep . kindlessCmm) args +
           continuation_frame_size next_format
           where 
             next_format = maybe unknown_format id $ lookup next' formats
@@ -375,7 +375,7 @@ continuationMaxStack formats (Continuation _ label _ False blocks) =
       final_arg_size _ = 0
 
       stmt_arg_size (CmmJump _ args) =
-          argumentsSize (cmmExprRep . hintlessCmm) args
+          argumentsSize (cmmExprRep . kindlessCmm) args
       stmt_arg_size (CmmCall _ _ _ (CmmSafe _) _) =
           panic "Safe call in processFormats"
       stmt_arg_size (CmmReturn _) =
diff --git a/compiler/cmm/CmmCPSGen.hs b/compiler/cmm/CmmCPSGen.hs
index 86eebfb0af..d508184889 100644
--- a/compiler/cmm/CmmCPSGen.hs
+++ b/compiler/cmm/CmmCPSGen.hs
@@ -227,7 +227,7 @@ continuationToProc (max_stack, update_frame_size, formats) stack_use uniques
                                 foreignCall call_uniques (CmmPrim target)
                                             results arguments
 
-formal_to_actual reg = CmmHinted (CmmReg (CmmLocal reg)) NoHint
+formal_to_actual reg = CmmKinded (CmmReg (CmmLocal reg)) NoHint
 
 foreignCall :: [Unique] -> CmmCallTarget -> CmmFormals -> CmmActuals -> [CmmStmt]
 foreignCall uniques call results arguments =
@@ -235,14 +235,14 @@ foreignCall uniques call results arguments =
     saveThreadState ++
     caller_save ++
     [CmmCall (CmmCallee suspendThread CCallConv)
-		 [ CmmHinted id PtrHint ]
-		 [ CmmHinted (CmmReg (CmmGlobal BaseReg)) PtrHint ]
+		 [ CmmKinded id PtrHint ]
+		 [ CmmKinded (CmmReg (CmmGlobal BaseReg)) PtrHint ]
 		 CmmUnsafe
                  CmmMayReturn,
      CmmCall call results new_args CmmUnsafe CmmMayReturn,
      CmmCall (CmmCallee resumeThread CCallConv)
-                 [ CmmHinted new_base PtrHint ]
-		 [ CmmHinted (CmmReg (CmmLocal id)) PtrHint ]
+                 [ CmmKinded new_base PtrHint ]
+		 [ CmmKinded (CmmReg (CmmLocal id)) PtrHint ]
 		 CmmUnsafe
                  CmmMayReturn,
      -- Assign the result to BaseReg: we
@@ -250,7 +250,7 @@ foreignCall uniques call results arguments =
      CmmAssign (CmmGlobal BaseReg) (CmmReg (CmmLocal new_base))] ++
     caller_load ++
     loadThreadState tso_unique ++
-    [CmmJump (CmmReg spReg) (map (formal_to_actual . hintlessCmm) results)]
+    [CmmJump (CmmReg spReg) (map (formal_to_actual . kindlessCmm) results)]
     where
       (_, arg_stmts, new_args) =
           loadArgsIntoTemps argument_uniques arguments
@@ -362,12 +362,12 @@ tail_call spRel target arguments
   = store_arguments ++ adjust_sp_reg spRel ++ jump where
     store_arguments =
         [stack_put spRel expr offset
-         | ((CmmHinted expr _), StackParam offset) <- argument_formats] ++
+         | ((CmmKinded expr _), StackParam offset) <- argument_formats] ++
         [global_put expr global
-         | ((CmmHinted expr _), RegisterParam global) <- argument_formats]
+         | ((CmmKinded expr _), RegisterParam global) <- argument_formats]
     jump = [CmmJump target arguments]
 
-    argument_formats = assignArguments (cmmExprRep . hintlessCmm) arguments
+    argument_formats = assignArguments (cmmExprRep . kindlessCmm) arguments
 
 adjust_sp_reg spRel =
     if spRel == 0
diff --git a/compiler/cmm/CmmLint.hs b/compiler/cmm/CmmLint.hs
index bf10135b5f..f36df5970e 100644
--- a/compiler/cmm/CmmLint.hs
+++ b/compiler/cmm/CmmLint.hs
@@ -136,7 +136,7 @@ lintCmmStmt labels = lint
             lintCmmExpr r
             return ()
           lint (CmmCall target _res args _ _) =
-              lintTarget target >> mapM_ (lintCmmExpr . hintlessCmm) args
+              lintTarget target >> mapM_ (lintCmmExpr . kindlessCmm) args
           lint (CmmCondBranch e id) = checkTarget id >> lintCmmExpr e >> checkCond e
           lint (CmmSwitch e branches) = do
             mapM_ checkTarget $ catMaybes branches
@@ -144,8 +144,8 @@ lintCmmStmt labels = lint
             if (erep == wordRep)
               then return ()
               else cmmLintErr (text "switch scrutinee is not a word: " <> ppr e)
-          lint (CmmJump e args) = lintCmmExpr e >> mapM_ (lintCmmExpr . hintlessCmm) args
-          lint (CmmReturn ress) = mapM_ (lintCmmExpr . hintlessCmm) ress
+          lint (CmmJump e args) = lintCmmExpr e >> mapM_ (lintCmmExpr . kindlessCmm) args
+          lint (CmmReturn ress) = mapM_ (lintCmmExpr . kindlessCmm) ress
           lint (CmmBranch id)    = checkTarget id
           checkTarget id = if elemBlockSet id labels then return ()
                            else cmmLintErr (text "Branch to nonexistent id" <+> ppr id)
diff --git a/compiler/cmm/CmmLive.hs b/compiler/cmm/CmmLive.hs
index f9973deb56..2450b70af3 100644
--- a/compiler/cmm/CmmLive.hs
+++ b/compiler/cmm/CmmLive.hs
@@ -164,7 +164,7 @@ addKilled new_killed live = live `minusUniqSet` new_killed
 -- Liveness of a CmmStmt
 --------------------------------
 cmmFormalsToLiveLocals :: CmmFormals -> [LocalReg]
-cmmFormalsToLiveLocals formals = map hintlessCmm formals
+cmmFormalsToLiveLocals formals = map kindlessCmm formals
 
 cmmStmtLive :: BlockEntryLiveness -> CmmStmt -> CmmLivenessTransformer
 cmmStmtLive _ (CmmNop) = id
@@ -179,7 +179,7 @@ cmmStmtLive _ (CmmStore expr1 expr2) =
     cmmExprLive expr2 . cmmExprLive expr1
 cmmStmtLive _ (CmmCall target results arguments _ _) =
     target_liveness .
-    foldr ((.) . cmmExprLive) id (map hintlessCmm arguments) .
+    foldr ((.) . cmmExprLive) id (map kindlessCmm arguments) .
     addKilled (mkUniqSet $ cmmFormalsToLiveLocals results) where
         target_liveness =
             case target of
@@ -197,9 +197,9 @@ cmmStmtLive other_live (CmmSwitch expr targets) =
            id
            (mapCatMaybes id targets))
 cmmStmtLive _ (CmmJump expr params) =
-    const (cmmExprLive expr $ foldr ((.) . cmmExprLive) id (map hintlessCmm params) $ emptyUniqSet)
+    const (cmmExprLive expr $ foldr ((.) . cmmExprLive) id (map kindlessCmm params) $ emptyUniqSet)
 cmmStmtLive _ (CmmReturn params) =
-    const (foldr ((.) . cmmExprLive) id (map hintlessCmm params) $ emptyUniqSet)
+    const (foldr ((.) . cmmExprLive) id (map kindlessCmm params) $ emptyUniqSet)
 
 --------------------------------
 -- Liveness of a CmmExpr
diff --git a/compiler/cmm/CmmOpt.hs b/compiler/cmm/CmmOpt.hs
index 6adafb5feb..9873e29cfd 100644
--- a/compiler/cmm/CmmOpt.hs
+++ b/compiler/cmm/CmmOpt.hs
@@ -155,7 +155,7 @@ inlineStmt u a (CmmCall target regs es srt ret)
    = CmmCall (infn target) regs es' srt ret
    where infn (CmmCallee fn cconv) = CmmCallee fn cconv
 	 infn (CmmPrim p) = CmmPrim p
-	 es' = [ (CmmHinted (inlineExpr u a e) hint) | (CmmHinted e hint) <- es ]
+	 es' = [ (CmmKinded (inlineExpr u a e) hint) | (CmmKinded e hint) <- es ]
 inlineStmt u a (CmmCondBranch e d) = CmmCondBranch (inlineExpr u a e) d
 inlineStmt u a (CmmSwitch e d) = CmmSwitch (inlineExpr u a e) d
 inlineStmt u a (CmmJump e d) = CmmJump (inlineExpr u a e) d
diff --git a/compiler/cmm/CmmProcPointZ.hs b/compiler/cmm/CmmProcPointZ.hs
index fc6b726544..59049d24cc 100644
--- a/compiler/cmm/CmmProcPointZ.hs
+++ b/compiler/cmm/CmmProcPointZ.hs
@@ -256,7 +256,7 @@ addProcPointProtocols procPoints formals g =
           maybe_add_proto (Block id _) env | id == lg_entry g =
               extendBlockEnv env id (Protocol stdArgConvention hinted_formals)
           maybe_add_proto _ env = env
-          hinted_formals = map (\x -> CmmHinted x NoHint) formals
+          hinted_formals = map (\x -> CmmKinded x NoHint) formals
           stdArgConvention = ConventionStandard CmmCallConv Arguments
 
 -- | For now, following a suggestion by Ben Lippmeier, we pass all
@@ -279,7 +279,7 @@ pass_live_vars_as_args procPoints (protos, g) = (protos', g')
               Nothing -> let live = lookupBlockEnv liveness id `orElse`
                                     emptyRegSet -- XXX there's a bug lurking!
                                     -- panic ("no liveness at block " ++ show id)
-                             formals = map (\x -> CmmHinted x NoHint) $ uniqSetToList live
+                             formals = map (\x -> CmmKinded x NoHint) $ uniqSetToList live
                          in  extendBlockEnv protos id (Protocol ConventionPrivate formals)
         g' = g { lg_blocks = add_CopyIns protos' (lg_blocks g) }
 
diff --git a/compiler/cmm/CmmUtils.hs b/compiler/cmm/CmmUtils.hs
index c44cc3a53a..1922ee05c4 100644
--- a/compiler/cmm/CmmUtils.hs
+++ b/compiler/cmm/CmmUtils.hs
@@ -197,10 +197,10 @@ loadArgsIntoTemps :: [Unique]
                   -> CmmActuals
                   -> ([Unique], [CmmStmt], CmmActuals)
 loadArgsIntoTemps uniques [] = (uniques, [], [])
-loadArgsIntoTemps uniques ((CmmHinted e hint):args) =
+loadArgsIntoTemps uniques ((CmmKinded e hint):args) =
     (uniques'',
      new_stmts ++ remaining_stmts,
-     (CmmHinted new_e hint) : remaining_e)
+     (CmmKinded new_e hint) : remaining_e)
     where
       (uniques', new_stmts, new_e) = maybeAssignTemp uniques e
       (uniques'', remaining_stmts, remaining_e) =
diff --git a/compiler/cmm/PprC.hs b/compiler/cmm/PprC.hs
index fca199c738..a943575d51 100644
--- a/compiler/cmm/PprC.hs
+++ b/compiler/cmm/PprC.hs
@@ -241,9 +241,9 @@ pprCFunType ppr_fn cconv ress args
     parens (commafy (map arg_type args))
   where
 	res_type [] = ptext (sLit "void")
-	res_type [CmmHinted one hint] = machRepHintCType (localRegRep one) hint
+	res_type [CmmKinded one hint] = machRepHintCType (localRegRep one) hint
 
-	arg_type (CmmHinted expr hint) = machRepHintCType (cmmExprRep expr) hint
+	arg_type (CmmKinded expr hint) = machRepHintCType (cmmExprRep expr) hint
 
 -- ---------------------------------------------------------------------
 -- unconditional branches
@@ -751,16 +751,16 @@ pprCall ppr_fn cconv results args _
     ppr_assign results (ppr_fn <> parens (commafy (map pprArg args))) <> semi
   where 
      ppr_assign []           rhs = rhs
-     ppr_assign [CmmHinted one hint] rhs
+     ppr_assign [CmmKinded one hint] rhs
 	 = pprLocalReg one <> ptext (sLit " = ")
 		 <> pprUnHint hint (localRegRep one) <> rhs
      ppr_assign _other _rhs = panic "pprCall: multiple results"
 
-     pprArg (CmmHinted expr hint)
+     pprArg (CmmKinded expr hint)
          | hint `elem` [PtrHint,SignedHint]
          = cCast (machRepHintCType (cmmExprRep expr) hint) expr
 	-- see comment by machRepHintCType below
-     pprArg (CmmHinted expr _other)
+     pprArg (CmmKinded expr _other)
          = pprExpr expr
 
      pprUnHint PtrHint    rep = parens (machRepCType rep)
@@ -844,8 +844,8 @@ te_Lit _ = return ()
 te_Stmt :: CmmStmt -> TE ()
 te_Stmt (CmmAssign r e)		= te_Reg r >> te_Expr e
 te_Stmt (CmmStore l r)		= te_Expr l >> te_Expr r
-te_Stmt (CmmCall _ rs es _ _)	= mapM_ (te_temp.hintlessCmm) rs >>
-				  mapM_ (te_Expr.hintlessCmm) es
+te_Stmt (CmmCall _ rs es _ _)	= mapM_ (te_temp.kindlessCmm) rs >>
+				  mapM_ (te_Expr.kindlessCmm) es
 te_Stmt (CmmCondBranch e _)	= te_Expr e
 te_Stmt (CmmSwitch e _)		= te_Expr e
 te_Stmt (CmmJump e _)		= te_Expr e
diff --git a/compiler/cmm/PprCmm.hs b/compiler/cmm/PprCmm.hs
index 24b1287bef..e26bb1be4d 100644
--- a/compiler/cmm/PprCmm.hs
+++ b/compiler/cmm/PprCmm.hs
@@ -246,9 +246,9 @@ pprStmt stmt = case stmt of
 		  | otherwise    = commafy (map ppr_ar results) <+> equals
 		-- Don't print the hints on a native C-- call
 	  ppr_ar arg = case cconv of
-			    CmmCallConv -> ppr (hintlessCmm arg)
-			    _   	-> doubleQuotes (ppr $ cmmHint arg) <+>
-                                           ppr (hintlessCmm arg)
+			    CmmCallConv -> ppr (kindlessCmm arg)
+			    _   	-> doubleQuotes (ppr $ cmmKind arg) <+>
+                                           ppr (kindlessCmm arg)
 	  _pp_conv = case cconv of
 		      CmmCallConv -> empty
 		      _ -> ptext (sLit "foreign") <+> doubleQuotes (ppr cconv)
@@ -294,7 +294,7 @@ genCondBranch expr ident =
 --
 --     jump foo(a, b, c);
 --
-genJump :: CmmExpr -> [CmmHinted CmmExpr] -> SDoc
+genJump :: CmmExpr -> [CmmKinded CmmExpr] -> SDoc
 genJump expr args = 
 
     hcat [ ptext (sLit "jump")
@@ -305,21 +305,21 @@ genJump expr args =
                     CmmLoad (CmmReg _) _ -> pprExpr expr 
                     _ -> parens (pprExpr expr)
          , space
-         , parens  ( commafy $ map pprHinted args )
+         , parens  ( commafy $ map pprKinded args )
          , semi ]
 
-pprHinted :: Outputable a => (CmmHinted a) -> SDoc
-pprHinted (CmmHinted a NoHint)     = ppr a
-pprHinted (CmmHinted a PtrHint)    = quotes(text "address") <+> ppr a
-pprHinted (CmmHinted a SignedHint) = quotes(text "signed")  <+> ppr a
-pprHinted (CmmHinted a FloatHint)  = quotes(text "float")   <+> ppr a
+pprKinded :: Outputable a => (CmmKinded a) -> SDoc
+pprKinded (CmmKinded a NoHint)     = ppr a
+pprKinded (CmmKinded a PtrHint)    = quotes(text "address") <+> ppr a
+pprKinded (CmmKinded a SignedHint) = quotes(text "signed")  <+> ppr a
+pprKinded (CmmKinded a FloatHint)  = quotes(text "float")   <+> ppr a
 
 -- --------------------------------------------------------------------------
 -- Return from a function. [1], Section 6.8.2 of version 1.128
 --
 --     return (a, b, c);
 --
-genReturn :: [CmmHinted CmmExpr] -> SDoc
+genReturn :: [CmmKinded CmmExpr] -> SDoc
 genReturn args = 
 
     hcat [ ptext (sLit "return")
diff --git a/compiler/cmm/ZipCfgCmmRep.hs b/compiler/cmm/ZipCfgCmmRep.hs
index 1fda97139e..47233e835e 100644
--- a/compiler/cmm/ZipCfgCmmRep.hs
+++ b/compiler/cmm/ZipCfgCmmRep.hs
@@ -14,7 +14,7 @@ where
 
 import CmmExpr
 import Cmm ( GenCmm(..), GenCmmTop(..), CmmStatic, CmmInfo
-           , CmmCallTarget(..), CmmActuals, CmmFormals, CmmHinted(..)
+           , CmmCallTarget(..), CmmActuals, CmmFormals, CmmKinded(..)
            , CmmStmt(..) -- imported in order to call ppr on Switch and to
                          -- implement pprCmmGraphLikeCmm
            , CmmSafety(CmmSafe) -- for pprCmmGraphLikeCmm
@@ -213,12 +213,12 @@ pprMiddle stmt = pp_stmt <+> pp_debug
 
     CopyIn conv args _ ->
         if null args then ptext (sLit "empty CopyIn")
-        else commafy (map pprHinted args) <+> equals <+>
+        else commafy (map pprKinded args) <+> equals <+>
              ptext (sLit "foreign") <+> doubleQuotes(ppr conv) <+> ptext (sLit "...")
 
     CopyOut conv args ->
         ptext (sLit "next, pass") <+> doubleQuotes(ppr conv) <+>
-        parens (commafy (map pprHinted args))
+        parens (commafy (map pprKinded args))
 
     --  // text
     MidComment s -> text "//" <+> ftext s
@@ -270,11 +270,11 @@ ppr_target t@(CmmLit _) = ppr t
 ppr_target fn'          = parens (ppr fn')
 
 
-pprHinted :: Outputable a => CmmHinted a -> SDoc
-pprHinted (CmmHinted a NoHint)     = ppr a
-pprHinted (CmmHinted a PtrHint)    = doubleQuotes (text "address") <+> ppr a
-pprHinted (CmmHinted a SignedHint) = doubleQuotes (text "signed")  <+> ppr a
-pprHinted (CmmHinted a FloatHint)  = doubleQuotes (text "float")   <+> ppr a
+pprKinded :: Outputable a => CmmKinded a -> SDoc
+pprKinded (CmmKinded a NoHint)     = ppr a
+pprKinded (CmmKinded a PtrHint)    = doubleQuotes (text "address") <+> ppr a
+pprKinded (CmmKinded a SignedHint) = doubleQuotes (text "signed")  <+> ppr a
+pprKinded (CmmKinded a FloatHint)  = doubleQuotes (text "float")   <+> ppr a
 
 pprLast :: Last -> SDoc    
 pprLast stmt = (case stmt of