packages feed

haskell-tools-prettyprint 0.4.1.1 → 0.4.1.2

raw patch · 11 files changed

+61/−78 lines, 11 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

Language/Haskell/Tools/IndentationUtils.hs view
@@ -1,11 +1,11 @@ -- | Utilities to modify the indentation of AST fragments
 module Language.Haskell.Tools.IndentationUtils where
 
-import Control.Reference
-import Control.Monad.Identity
+import Control.Monad.Identity (Identity(..))
+import Control.Reference ((.=))
 
-import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.Transform.SourceTemplate
+import Language.Haskell.Tools.AST (SrcTemplateStage(..), SourceInfoTrf(..), SourceInfoTraversal(..))
+import Language.Haskell.Tools.Transform.SourceTemplate (sourceTemplateMinimalIndent, srcTmpListMinimalIndent, srcTmpOptMinimalIndent)
 
 -- | Set the minimal indentation recursively for a part of the AST
 setMinimalIndent :: SourceInfoTraversal elem
Language/Haskell/Tools/PrettyPrint.hs view
@@ -7,24 +7,19 @@ -- | Pretty printing the AST
 module Language.Haskell.Tools.PrettyPrint (prettyPrint) where
 
+import FastString (fsLit)
 import SrcLoc
-import FastString
 
-import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.PrettyPrint.RoseTree
+import Language.Haskell.Tools.AST (SrcTemplateStage(..), SourceInfoTraversal(..))
+import Language.Haskell.Tools.PrettyPrint.RoseTree (RoseSourceInfo(..), RoseTree(..), toRoseTree)
 import Language.Haskell.Tools.Transform.SourceTemplate
 
 import Control.Monad.State
-import Control.Reference
-import Data.Maybe
+import Data.Foldable (Foldable(..), concat)
 import Data.List as List
-import Data.List.Split
-import Data.Foldable
+import Data.List.Split (splitOn)
 import Data.Sequence hiding (null, replicate)
-import Language.Haskell.Tools.AST
 
-import Debug.Trace
-
 -- | Pretty prints an AST by using source templates stored as node info
 prettyPrint :: (SourceInfoTraversal node) => node dom SrcTemplateStage -> String
 prettyPrint = toList . printRose . toRoseTree
@@ -41,7 +36,6 @@ -- warning: the length of the file should not exceed maxbound::Int
 printRose' parent (RoseTree (RoseSpan (SourceTemplateNode rng elems minInd relInd)) children) 
   = do slide <- calculateSlide rng
-       actRng <- get
        let printTemplateElems :: [SourceTemplateElem] -> [RoseTree SrcTemplateStage] -> PPState (Seq Char)
            printTemplateElems (TextElem txt : rest) children = putString slide min txt >+< printTemplateElems rest children
            printTemplateElems (ChildElem : rest) (child : children) = printRose' parent child >+< printTemplateElems rest children
@@ -129,4 +123,4 @@ printListWithSeps' _ parent _ _ _ [child] = printRose' parent child
 printListWithSeps' putCorrectSep parent slide minInd (sep:seps) (child:children) 
   = printRose' parent child >+< putCorrectSep slide minInd sep >+< printListWithSeps' putCorrectSep parent slide minInd seps children
-    
+printListWithSeps' _ _ _ _ [] _ = error "printListWithSeps': the number of elements and separators does not match"
Language/Haskell/Tools/PrettyPrint/RoseTree.hs view
@@ -6,7 +6,7 @@ -- | A simpler representation of the original AST.
 module Language.Haskell.Tools.PrettyPrint.RoseTree where
 
-import Control.Monad.State
+import Control.Monad.State (Monad(..), execState, modify)
 import Language.Haskell.Tools.AST
 
 -- | A rose tree containing additional node information
Language/Haskell/Tools/Transform.hs view
@@ -13,15 +13,15 @@   , rangeToSource, fixRanges, cutUpRanges, getLocIndices, mapLocIndices
   ) where
 
-import Language.Haskell.Tools.Transform.RangeToRangeTemplate
-import Language.Haskell.Tools.Transform.RangeTemplateToSourceTemplate
-import Language.Haskell.Tools.Transform.RangeTemplate
+import Language.Haskell.Tools.Transform.PlaceComments (getNormalComments, getPragmaComments, placeComments)
+import Language.Haskell.Tools.Transform.RangeTemplate ()
+import Language.Haskell.Tools.Transform.RangeTemplateToSourceTemplate (rangeToSource, getLocIndices, mapLocIndices)
+import Language.Haskell.Tools.Transform.RangeToRangeTemplate (cutUpRanges, fixRanges)
 import Language.Haskell.Tools.Transform.SourceTemplate
 import Language.Haskell.Tools.Transform.SourceTemplateHelpers
-import Language.Haskell.Tools.Transform.PlaceComments
 
 import Language.Haskell.Tools.AST
-import StringBuffer
+import StringBuffer (StringBuffer(..))
 
 -- | Prepares the AST for pretty printing
 prepareAST :: SourceInfoTraversal node => StringBuffer -> Ann node dom RangeStage -> Ann node dom SrcTemplateStage
Language/Haskell/Tools/Transform/PlaceComments.hs view
@@ -6,21 +6,16 @@ -- normalizing transformation should be performed that expands parents to contain their children.
 module Language.Haskell.Tools.Transform.PlaceComments where
 
+import Control.Monad.State
+import Control.Monad.Writer
+import Control.Reference hiding (element)
+import Data.Char (isSpace, isAlphaNum)
 import qualified Data.Map as Map
-import qualified Data.Set as Set
 import Data.Maybe
-import Data.List
-import Data.Char (isSpace, isAlphaNum)
-import Data.Data
-import Data.Generics.Uniplate.Data
-import Control.Reference hiding (element)
-import Control.Monad.Writer
-import Control.Monad.State
+import qualified Data.Set as Set (lookupLE, lookupGE, fromList)
 
+import ApiAnnotation (AnnotationComment(..))
 import SrcLoc
-import ApiAnnotation
-import Outputable
-import Debug.Trace
 
 import Language.Haskell.Tools.AST
Language/Haskell/Tools/Transform/RangeTemplate.hs view
@@ -8,10 +8,10 @@ -- had been cut from the parent nodes, but the annotations still contain ranges instead of text.
 module Language.Haskell.Tools.Transform.RangeTemplate where
 
-import Data.Data
 import Control.Reference
-import SrcLoc
+import Data.Data
 import Language.Haskell.Tools.AST
+import SrcLoc
 
 instance SourceInfo RngTemplateStage where
   data SpanInfo RngTemplateStage = RangeTemplateNode { _rngTemplateNodeRange :: RealSrcSpan
@@ -93,10 +93,10 @@ instance Show (SpanInfo RngTemplateStage) where
   show rngNode = concatMap show $ rngNode ^. rngTemplateNodeElems
 instance Show (ListInfo RngTemplateStage) where
-  show RangeTemplateList{..} = "«*" ++ shortShowSpan (RealSrcSpan _rngTemplateListRange) ++ " " ++ show _rngTmpListBefore ++ " " ++ show _rngTmpDefaultSeparator ++ " " ++ show _rngTmpListAfter ++ "*»"
+  show RangeTemplateList{..} = "<*" ++ shortShowSpan (RealSrcSpan _rngTemplateListRange) ++ " " ++ show _rngTmpListBefore ++ " " ++ show _rngTmpDefaultSeparator ++ " " ++ show _rngTmpListAfter ++ "*>"
 instance Show (OptionalInfo RngTemplateStage) where
-  show RangeTemplateOpt{..} = "«?" ++ shortShowSpan (RealSrcSpan _rngTemplateOptRange) ++ " " ++ show _rngTmpOptBefore ++ " " ++ show _rngTmpOptAfter ++ "?»"
+  show RangeTemplateOpt{..} = "<?" ++ shortShowSpan (RealSrcSpan _rngTemplateOptRange) ++ " " ++ show _rngTmpOptBefore ++ " " ++ show _rngTmpOptAfter ++ "?>"
                        
 instance Show RangeTemplateElem where
   show (RangeElem sp) = shortShowSpan (RealSrcSpan sp)
-  show RangeChildElem = "«.»"
+  show RangeChildElem = "<.>"
Language/Haskell/Tools/Transform/RangeTemplateToSourceTemplate.hs view
@@ -5,18 +5,14 @@ -- Basically it reads the source file and attaches parts of the source file to the AST elements that have the range of the given source code fragment.
 module Language.Haskell.Tools.Transform.RangeTemplateToSourceTemplate where
 
-import SrcLoc
-import StringBuffer
-import Data.Map
-import Data.Monoid
-import Control.Reference
 import Control.Monad.State
+import Control.Reference ((^.))
+import Data.Map
 import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.Transform.RangeToRangeTemplate
 import Language.Haskell.Tools.Transform.RangeTemplate
 import Language.Haskell.Tools.Transform.SourceTemplate
-
-import Debug.Trace
+import SrcLoc
+import StringBuffer (StringBuffer(..), nextChar, atEnd)
 
 rangeToSource :: SourceInfoTraversal node => StringBuffer -> Ann node dom RngTemplateStage
                                                           -> Ann node dom SrcTemplateStage
@@ -43,6 +39,7 @@                                                              in (insert k (reverse val) new, rem)) (empty, inp)
   where takeSpan :: StringBuffer -> OrdSrcSpan -> (StringBuffer, String)
         takeSpan str (OrdSrcSpan sp) = takeSpan' (realSrcSpanStart sp) (realSrcSpanEnd sp) (str,"")
+        takeSpan _ (NoOrdSrcSpan {}) = error "takeSpan: missing source span"
 
         takeSpan' :: RealSrcLoc -> RealSrcLoc -> (StringBuffer, String) -> (StringBuffer, String)
         takeSpan' start end (sb, taken) | start < end && not (atEnd sb)
@@ -63,6 +60,6 @@      (\(RangeTemplateOpt rng bef aft) -> return (SourceTemplateOpt (RealSrcSpan rng) bef aft 0 Nothing))) 
      (return ()) (return ())
   where getTextFor RangeChildElem = return ChildElem
-        getTextFor (RangeElem sp) = do (src:rest) <- get
-                                       put rest
-                                       return (TextElem src)+        getTextFor (RangeElem _) = do (src:rest) <- get
+                                      put rest
+                                      return (TextElem src)
Language/Haskell/Tools/Transform/RangeToRangeTemplate.hs view
@@ -8,17 +8,15 @@ 
 import Language.Haskell.Tools.AST
 
-import Data.Data
-import Data.List
-import Data.Maybe
-import Control.Reference hiding (element)
 import Control.Monad.State
-import SrcLoc
-import Language.Haskell.Tools.Transform.RangeTemplate
+import Control.Reference ((^.))
+import Data.List
+import Data.Maybe (Maybe(..), maybe, mapMaybe)
 
-import FastString as GHC
+import FastString as GHC (unpackFS)
+import SrcLoc
 
-import Debug.Trace
+import Language.Haskell.Tools.Transform.RangeTemplate
 
 -- | Creates a source template from the ranges and the input file.
 -- All source ranges must be good ranges.
@@ -26,8 +24,7 @@                  => Ann node dom NormRangeStage
                  -> Ann node dom RngTemplateStage
 cutUpRanges n = evalState (cutUpRanges' n) [[],[]]
-  where cutUpRanges' :: SourceInfoTraversal node => Ann node dom NormRangeStage
-                                                 -> State [[SrcSpan]] (Ann node dom RngTemplateStage)
+  where cutUpRanges' :: Ann node dom NormRangeStage -> State [[SrcSpan]] (Ann node dom RngTemplateStage)
         cutUpRanges' = sourceInfoTraverseUp (SourceInfoTrf (trf cutOutElemSpan) (trf cutOutElemList) (trf cutOutElemOpt)) desc asc
         
         -- keep the stack to contain the children elements on the place of the parent element
@@ -35,7 +32,7 @@         asc  = modify tail
         
         -- combine the current node with its children, and add it to the list of current nodes
-        trf :: (Show (x NormRangeStage), Show (x RngTemplateStage), HasRange (x NormRangeStage), HasRange (x RngTemplateStage)) 
+        trf :: HasRange (x RngTemplateStage)
             => ([SrcSpan] -> x NormRangeStage -> x RngTemplateStage) -> x NormRangeStage -> State [[SrcSpan]] (x RngTemplateStage)
         trf f ni = do (below : top : xs) <- get
                       let res = f below ni
@@ -51,7 +48,7 @@         desc = modify ([]:)
         asc  = modify tail
         
-        trf :: (HasRange (x RangeStage), HasRange (x NormRangeStage)) 
+        trf :: HasRange (x NormRangeStage)
             => ([SrcSpan] -> x RangeStage -> x NormRangeStage) -> x RangeStage -> State [[SrcSpan]] (x NormRangeStage)
         trf f ni = do (below : top : xs) <- get
                       let res = f below ni
@@ -84,28 +81,31 @@               Just pieces -> pieces ++ rest
               Nothing -> elem : breakFirstHit rest sp
         breakFirstHit [] sp = error ("breakFirstHit: " ++ maybe "" unpackFS (srcSpanFileName_maybe sp) ++ " didn't find correct place for " ++ shortShowSpan sp ++ " in " ++ shortShowSpan sp ++ " with [" ++ concat (intersperse "," (map shortShowSpan sps)) ++ "]")
+cutOutElemSpan _ (NormNodeInfo (UnhelpfulSpan {})) = error "cutOutElemSpan: no real span"
 
 cutOutElemList :: [SrcSpan] -> ListInfo NormRangeStage -> ListInfo RngTemplateStage
-cutOutElemList sps lp@(NormListInfo bef aft sep indented sp)
+cutOutElemList sps (NormListInfo bef aft sep indented sp)
   = let RealSrcSpan wholeRange = foldl1 combineSrcSpans $ sp : sps
      in RangeTemplateList wholeRange bef aft sep indented (getSeparators wholeRange sps)
 
 cutOutElemOpt :: [SrcSpan] -> OptionalInfo NormRangeStage -> OptionalInfo RngTemplateStage
-cutOutElemOpt sps op@(NormOptInfo bef aft sp) 
+cutOutElemOpt sps (NormOptInfo bef aft sp) 
   = let RealSrcSpan wholeRange = foldl1 combineSrcSpans $ sp : sps
      in RangeTemplateOpt wholeRange bef aft
 
 collectSpanRanges :: SrcLoc -> [SrcSpan] -> RealSrcSpan
 collectSpanRanges (RealSrcLoc loc) [] = realSrcLocSpan loc
 collectSpanRanges _ [] = error "collectSpanRanges: No real src loc for empty element"
-collectSpanRanges _ ls = case foldl1 combineSrcSpans ls of RealSrcSpan sp -> sp
+collectSpanRanges _ ls = case foldl1 combineSrcSpans ls of 
+                           RealSrcSpan sp -> sp
+                           UnhelpfulSpan {} -> error "collectSpanRanges: combineSrcSpans resulted no real span"
                      
 -- | Cuts out all elements from a list, the rest is the list of separators
 getSeparators :: RealSrcSpan -> [SrcSpan] -> [RealSrcSpan]
 getSeparators sp infos@(_:_:_)
   = mapMaybe getRangeElemSpan (cutOutElemSpan infos (NormNodeInfo (RealSrcSpan sp)) ^. rngTemplateNodeElems)
 -- at least two elements needed or there can be no separators
-getSeparators sp _ = []
+getSeparators _ _ = []
                      
 -- | Breaks the given template element into possibly 2 or 3 parts by cutting out the given part
 -- if it is inside the range of the template element. Returns Nothing if the second argument is not inside.
@@ -119,6 +119,6 @@            (if (realSrcSpanEnd inner) < (realSrcSpanEnd outer) 
               then [ RangeElem (mkRealSrcSpan (realSrcSpanEnd inner) (realSrcSpanEnd outer)) ]
               else [])
-breakUpRangeElem outer inner = Nothing
+breakUpRangeElem _ _ = Nothing
Language/Haskell/Tools/Transform/SourceTemplate.hs view
@@ -9,11 +9,10 @@ -- the children specified by placeholders.
 module Language.Haskell.Tools.Transform.SourceTemplate where
 
-import Data.Data
-import Data.String
 import Control.Reference
-import SrcLoc
+import Data.Data
 import Language.Haskell.Tools.AST
+import SrcLoc
 
 instance SourceInfo SrcTemplateStage where
   data SpanInfo SrcTemplateStage 
@@ -124,11 +123,11 @@ instance Show (SpanInfo SrcTemplateStage) where
   show (SourceTemplateNode _ sp _ _) = concatMap show sp
 instance Show (ListInfo SrcTemplateStage) where
-  show SourceTemplateList{..} = "«*" ++ show _srcTmpListBefore ++ " " ++ show _srcTmpDefaultSeparator ++ " " ++ show _srcTmpListAfter ++ "*»"
+  show SourceTemplateList{..} = "<*" ++ show _srcTmpListBefore ++ " " ++ show _srcTmpDefaultSeparator ++ " " ++ show _srcTmpListAfter ++ "*>"
 instance Show (OptionalInfo SrcTemplateStage) where
-  show SourceTemplateOpt{..} = "«?" ++ show _srcTmpOptBefore ++ " " ++ show _srcTmpOptAfter ++ "?»"
+  show SourceTemplateOpt{..} = "<?" ++ show _srcTmpOptBefore ++ " " ++ show _srcTmpOptAfter ++ "?>"
 
 instance Show SourceTemplateElem where
   show (TextElem s) = s
-  show ChildElem = "«.»"
+  show ChildElem = "<.>"
Language/Haskell/Tools/Transform/SourceTemplateHelpers.hs view
@@ -5,13 +5,11 @@ -- | Helper functions for working with source templates
 module Language.Haskell.Tools.Transform.SourceTemplateHelpers where
 
-import SrcLoc
-import Data.String
-import Data.List
-import Control.Reference
-import Data.Function (on)
+import Control.Reference ((.=))
+import Data.String (IsString(..), String(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.Transform.SourceTemplate
+import SrcLoc (noSrcSpan, combineSrcSpans)
 
 type ASTElement node dom = Ann node dom SrcTemplateStage
 type ASTOptional node dom = AnnMaybeG node dom SrcTemplateStage
haskell-tools-prettyprint.cabal view
@@ -1,5 +1,5 @@ name:                haskell-tools-prettyprint
-version:             0.4.1.1
+version:             0.4.1.2
 synopsis:            Pretty printing of Haskell-Tools AST
 description:         Converts the Haskell-Tools AST to text. Prepares the AST for this conversion. If the AST was created from the GHC AST this pretty printing will result in the original source code. Generated AST parts will get the default formatting. Works using the source annotations that are present in the AST. Creates a rose tree first to simplify the conversion.
 homepage:            https://github.com/haskell-tools/haskell-tools