haskell-tools-rewrite 0.4.1.3 → 0.5.0.0

raw patch · 16 files changed

+50/−50 lines, 16 filesdep ~haskell-tools-astdep ~haskell-tools-prettyprintdep ~haskell-tools-rewritePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: haskell-tools-ast, haskell-tools-prettyprint, haskell-tools-rewrite

API changes (from Hackage documentation)

- Language.Haskell.Tools.AST.Gen.Decls: mkNoInlinePragma :: Maybe (ConlikeAnnot dom) -> Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom

+ Language.Haskell.Tools.AST.Gen.Decls: mkNoInlinePragma :: Name dom -> TopLevelPragma dom

- Language.Haskell.Tools.AST.Gen.Modules: mkModuleHead :: ModuleName dom -> Maybe (ExportSpecs dom) -> Maybe (ModulePragma dom) -> ModuleHead dom

+ Language.Haskell.Tools.AST.Gen.Modules: mkModuleHead :: ModuleName dom -> Maybe (ModulePragma dom) -> Maybe (ExportSpecs dom) -> ModuleHead dom

Files

Language/Haskell/Tools/AST/Gen/Binds.hs +3/−3
Language/Haskell/Tools/AST/Gen/Decls.hs +7/−8
Language/Haskell/Tools/AST/Gen/Exprs.hs +2/−2
Language/Haskell/Tools/AST/Gen/Kinds.hs +2/−2
Language/Haskell/Tools/AST/Gen/Literals.hs +2/−2
Language/Haskell/Tools/AST/Gen/Modules.hs +4/−4
Language/Haskell/Tools/AST/Gen/Names.hs +1/−1
Language/Haskell/Tools/AST/Gen/TH.hs +1/−1
Language/Haskell/Tools/AST/Gen/Types.hs +2/−2
Language/Haskell/Tools/AST/Gen/Utils.hs +1/−1
Language/Haskell/Tools/AST/Match/Binds.hs +8/−6
Language/Haskell/Tools/AST/Match/Decls.hs +4/−4
Language/Haskell/Tools/AST/Match/Literals.hs +1/−1
Language/Haskell/Tools/AST/Match/Modules.hs +2/−3
haskell-tools-rewrite.cabal +6/−6
test/Main.hs +4/−4

Language/Haskell/Tools/AST/Gen/Binds.hs view

@@ -72,17 +72,17 @@ -- | Creates a left-associative fixity declaration (@ infixl 5 +, - @).
 mkInfixL :: Int -> Operator dom -> FixitySignature dom
 mkInfixL prec op = mkAnn (child <> " " <> child <> " " <> child) 
-                     $ UFixitySignature (mkAnn "infixl" AssocLeft) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
+                     $ UFixitySignature (mkAnn "infixl" AssocLeft) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates a right-associative fixity declaration (@ infixr 5 +, - @).
 mkInfixR :: Int -> Operator dom -> FixitySignature dom
 mkInfixR prec op = mkAnn (child <> " " <> child <> " " <> child) 
-                     $ UFixitySignature (mkAnn "infixr" AssocRight) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
+                     $ UFixitySignature (mkAnn "infixr" AssocRight) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates a non-associative fixity declaration (@ infix 5 +, - @).
 mkInfix :: Int -> Operator dom -> FixitySignature dom
 mkInfix prec op = mkAnn (child <> " " <> child <> " " <> child) 
-                    $ UFixitySignature (mkAnn "infix" AssocNone) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
+                    $ UFixitySignature (mkAnn "infix" AssocNone) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates an unguarded right-hand-side (@ = 3 @)
 mkUnguardedRhs :: Expr dom -> Rhs dom

Language/Haskell/Tools/AST/Gen/Decls.hs view

@@ -424,20 +424,19 @@ -- | A pragma that marks a function for inlining to the compiler (@ {-\# INLINE thenUs \#-} @)
 mkInlinePragma :: Maybe (ConlikeAnnot dom) -> Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom
 mkInlinePragma conlike phase name 
-  = mkAnn ("{-# INLINE " <> child <> child <> child <> " #-}") 
-      $ UInlinePragma (mkAnnMaybe (followedBy " " opt) conlike) (mkAnnMaybe (followedBy " " opt) phase) name
+  = mkAnn ("{-# INLINE " <> child <> child <> child <> " #-}") $ UInlinePragmaDecl
+      $ mkAnn child $ UInlinePragma (mkAnnMaybe (followedBy " " opt) conlike) (mkAnnMaybe (followedBy " " opt) phase) name
 
 -- | A pragma that forbids a function from being inlined by the compiler (@ {-\# NOINLINE f \#-} @)
-mkNoInlinePragma :: Maybe (ConlikeAnnot dom) -> Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom
-mkNoInlinePragma conlike phase name 
-  = mkAnn ("{-# NOINLINE " <> child <> child <> child <> " #-}") 
-     $ UNoInlinePragma (mkAnnMaybe (followedBy " " opt) conlike) (mkAnnMaybe (followedBy " " opt) phase) name
+mkNoInlinePragma :: Name dom -> TopLevelPragma dom
+mkNoInlinePragma name = mkAnn ("{-# NOINLINE " <> child <> " #-}") $ UInlinePragmaDecl
+      $ mkAnn child $ UNoInlinePragma name
 
 -- | A pragma that marks a function that it may be inlined by the compiler (@ {-\# INLINABLE thenUs \#-} @)
 mkInlinablePragma :: Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom
 mkInlinablePragma phase name
-  = mkAnn ("{-# INLINEABLE " <> child <> child <> " #-}") 
-     $ UInlinablePragma (mkAnnMaybe (followedBy " " opt) phase) name
+  = mkAnn ("{-# INLINEABLE " <> child <> child <> " #-}") $ UInlinePragmaDecl
+      $ mkAnn child $ UInlinablePragma (mkAnnMaybe (followedBy " " opt) phase) name
 
 -- | A pragma for maintaining line numbers in generated sources (@ {-\# LINE 123 "somefile" \#-} @)
 mkLinePragma :: Int -> Maybe (StringNode dom) -> TopLevelPragma dom

Language/Haskell/Tools/AST/Gen/Exprs.hs view

@@ -91,11 +91,11 @@ 
 -- | Create a left operator section: @(1+)@
 mkLeftSection :: Expr dom -> Operator dom -> Expr dom
-mkLeftSection lhs op = mkAnn ("(" <> child <> child <> ")") $ ULeftSection lhs op
+mkLeftSection lhs op = mkAnn ("(" <> child <> " " <> child <> ")") $ ULeftSection lhs op
 
 -- | Create a right operator section: @(+1)@
 mkRightSection :: Operator dom -> Expr dom -> Expr dom
-mkRightSection op rhs = mkAnn ("(" <> child <> child <> ")") $ URightSection op rhs
+mkRightSection op rhs = mkAnn ("(" <> child <> " " <> child <> ")") $ URightSection op rhs
 
 -- | Create a record value construction: @Point { x = 3, y = -2 }@
 mkRecCon :: Name dom -> [FieldUpdate dom] -> Expr dom

Language/Haskell/Tools/AST/Gen/Kinds.hs view

@@ -5,9 +5,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Kinds where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST (UPromoted(..), UKind(..), UKindConstraint(..))
-import Language.Haskell.Tools.AST.ElementTypes (Name(..), Kind(..), KindConstraint(..))
+import Language.Haskell.Tools.AST.ElementTypes (Name, Kind, KindConstraint)
 import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList)
 import Language.Haskell.Tools.Transform

Language/Haskell/Tools/AST/Gen/Literals.hs view

@@ -5,9 +5,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Literals where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST (ULiteral(..))
-import Language.Haskell.Tools.AST.ElementTypes (Literal(..))
+import Language.Haskell.Tools.AST.ElementTypes (Literal)
 import Language.Haskell.Tools.AST.Gen.Utils (mkAnn)
 
 -- | Character literal: @'c'@

Language/Haskell/Tools/AST/Gen/Modules.hs view

@@ -6,7 +6,7 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Modules where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Gen.Names (mkStringNode)
@@ -22,9 +22,9 @@                 (mkAnnList (after "\n" $ indented list) imps) (mkAnnList (after "\n" $ indented list) decls)
                
 -- | Module declaration with name and (optional) exports
-mkModuleHead :: ModuleName dom -> Maybe (ExportSpecs dom) -> Maybe (ModulePragma dom) -> ModuleHead dom
-mkModuleHead n es pr = mkAnn ("module " <> child <> child <> child <> " where") 
-                         $ UModuleHead n (mkAnnMaybe opt es) (mkAnnMaybe (after "\n" opt) pr)
+mkModuleHead :: ModuleName dom -> Maybe (ModulePragma dom) -> Maybe (ExportSpecs dom) -> ModuleHead dom
+mkModuleHead n pr es = mkAnn ("module " <> child <> child <> child <> " where") 
+                         $ UModuleHead n (mkAnnMaybe (after "\n" opt) pr) (mkAnnMaybe opt es)
 
 -- | A list of export specifications surrounded by parentheses
 mkExportSpecs :: [ExportSpec dom] -> ExportSpecs dom

Language/Haskell/Tools/AST/Gen/Names.hs view

@@ -5,7 +5,7 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Names where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Gen.Utils (emptyList, mkAnn, mkAnnList)

Language/Haskell/Tools/AST/Gen/TH.hs view

@@ -4,7 +4,7 @@            #-}
 module Language.Haskell.Tools.AST.Gen.TH where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList)

Language/Haskell/Tools/AST/Gen/Types.hs view

@@ -6,14 +6,14 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Types where
 
-import Data.String (IsString(..), String(..))
+import Data.String (IsString(..), String)
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Gen.Kinds (mkKindConstraint)
 import Language.Haskell.Tools.AST.Gen.Names (mkUnqualName')
 import Language.Haskell.Tools.AST.Gen.Utils
 import Language.Haskell.Tools.Transform
-import qualified Name as GHC (Name(..))
+import qualified Name as GHC (Name)
 
 -- * Generation of types

Language/Haskell/Tools/AST/Gen/Utils.hs view

@@ -5,7 +5,7 @@ module Language.Haskell.Tools.AST.Gen.Utils where
 
 import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.AST.ElementTypes (AnnMaybe(..), AnnList(..))
+import Language.Haskell.Tools.AST.ElementTypes (AnnMaybe, AnnList)
 import Language.Haskell.Tools.Transform (child, opt, list)
 
 fromTemplate :: src -> NodeInfo sema src

Language/Haskell/Tools/AST/Match/Binds.hs view

@@ -45,17 +45,19 @@ pattern TypeSignature :: NameList dom -> Type dom -> TypeSignature dom
 pattern TypeSignature n t <- Ann _ (UTypeSignature n t)
 
+-- TODO: match precedence with maybe
+
 -- | A left-associative fixity declaration (@ infixl 5 +, - @).
-pattern InfixL :: Int -> OperatorList dom -> FixitySignature dom
-pattern InfixL prec op <- Ann _ (UFixitySignature (Ann _ AssocLeft) (Ann _ (Precedence prec)) op)
+pattern InfixL :: OperatorList dom -> FixitySignature dom
+pattern InfixL op <- Ann _ (UFixitySignature (Ann _ AssocLeft) _ op)
 
 -- | A right-associative fixity declaration (@ infixr 5 +, - @).
-pattern InfixR :: Int -> OperatorList dom -> FixitySignature dom
-pattern InfixR prec op <- Ann _ (UFixitySignature (Ann _ AssocRight) (Ann _ (Precedence prec)) op)
+pattern InfixR :: OperatorList dom -> FixitySignature dom
+pattern InfixR op <- Ann _ (UFixitySignature (Ann _ AssocRight) _ op)
 
 -- | A non-associative fixity declaration (@ infix 5 +, - @).
-pattern Infix :: Int -> OperatorList dom -> FixitySignature dom
-pattern Infix prec op <- Ann _ (UFixitySignature (Ann _ AssocNone) (Ann _ (Precedence prec)) op)
+pattern Infix :: OperatorList dom -> FixitySignature dom
+pattern Infix op <- Ann _ (UFixitySignature (Ann _ AssocNone) _ op)
 
 -- | An unguarded right-hand-side (@ = 3 @)
 pattern UnguardedRhs :: Expr dom -> Rhs dom

Language/Haskell/Tools/AST/Match/Decls.hs view

@@ -383,15 +383,15 @@ 
 -- | A pragma that marks a function for inlining to the compiler (@ {-\# INLINE thenUs \#-} @)
 pattern InlinePragma :: MaybeConlikeAnnot dom -> MaybePhaseControl dom -> Name dom -> TopLevelPragma dom
-pattern InlinePragma conlike phase name <- Ann _ (UInlinePragma conlike phase name)
+pattern InlinePragma conlike phase name <- Ann _ (UInlinePragmaDecl (Ann _ (UInlinePragma conlike phase name)))
 
 -- | A pragma that forbids a function from being inlined by the compiler (@ {-\# NOINLINE f \#-} @)
-pattern NoInlinePragma :: MaybeConlikeAnnot dom -> MaybePhaseControl dom -> Name dom -> TopLevelPragma dom
-pattern NoInlinePragma conlike phase name <- Ann _ (UNoInlinePragma conlike phase name)
+pattern NoInlinePragma :: Name dom -> TopLevelPragma dom
+pattern NoInlinePragma name <- Ann _ (UInlinePragmaDecl (Ann _ (UNoInlinePragma name)))
 
 -- | A pragma that marks a function that it may be inlined by the compiler (@ {-\# INLINABLE thenUs \#-} @)
 pattern InlinablePragma :: MaybePhaseControl dom -> Name dom -> TopLevelPragma dom
-pattern InlinablePragma phase name <- Ann _ (UInlinablePragma phase name)
+pattern InlinablePragma phase name <- Ann _ (UInlinePragmaDecl (Ann _ (UInlinablePragma phase name)))
 
 -- | A pragma for maintaining line numbers in generated sources (@ {-\# LINE 123 \"somefile\" \#-} @)
 pattern LinePragma :: Int -> MaybeStringNode dom -> TopLevelPragma dom

Language/Haskell/Tools/AST/Match/Literals.hs view

@@ -3,7 +3,7 @@ module Language.Haskell.Tools.AST.Match.Literals where
 
 import Language.Haskell.Tools.AST (ULiteral(..), Ann(..))
-import Language.Haskell.Tools.AST.ElementTypes (Literal(..))
+import Language.Haskell.Tools.AST.ElementTypes (Literal)
 
 -- | Character literal: @'c'@
 pattern CharLit :: Char -> Literal dom

Language/Haskell/Tools/AST/Match/Modules.hs view

@@ -12,9 +12,8 @@ pattern Module filePrags head imps decls  <- Ann _ (UModule filePrags head imps decls )
 
 -- | Module declaration with name and (optional) exports
-pattern ModuleHead :: ModuleName dom -> MaybeExportSpecs dom 
-                  -> MaybeModulePragma dom -> ModuleHead dom
-pattern ModuleHead n es pr <- Ann _ (UModuleHead n es pr)
+pattern ModuleHead :: ModuleName dom -> MaybeModulePragma dom -> MaybeExportSpecs dom -> ModuleHead dom
+pattern ModuleHead n pr es <- Ann _ (UModuleHead n pr es)
 
 -- | A list of export specifications surrounded by parentheses
 pattern ExportSpecs :: ExportSpecList dom -> ExportSpecs dom

haskell-tools-rewrite.cabal view

@@ -1,5 +1,5 @@ name:                haskell-tools-rewrite
-version:             0.4.1.3
+version:             0.5.0.0
 synopsis:            Facilities for generating new parts of the Haskell-Tools AST
 description:         Contains utility functions to generate parts of the Haskell-Tools AST. Generates these elements to be compatible with the source annotations that are already present on the AST. The package is divided into modules based on which language elements can the given module generate. This packages should be used during the transformations to generate parts of the new AST.
 homepage:            https://github.com/haskell-tools/haskell-tools
@@ -45,8 +45,8 @@                      , containers                >= 0.5  && < 0.6
                      , references                >= 0.3  && < 0.4
                      , ghc                       >= 8.0  && < 8.1
-                     , haskell-tools-ast         >= 0.4  && < 0.5
-                     , haskell-tools-prettyprint >= 0.4  && < 0.5
+                     , haskell-tools-ast         >= 0.5  && < 0.6
+                     , haskell-tools-prettyprint >= 0.5  && < 0.6
   default-language:    Haskell2010
 
 test-suite haskell-tools-rewrite-tests
@@ -59,7 +59,7 @@                      , tasty-hunit               >= 0.9 && < 0.10
                      , directory                 >= 1.2 && < 1.4
                      , filepath                  >= 1.4 && < 2.0
-                     , haskell-tools-ast         >= 0.4 && < 0.5
-                     , haskell-tools-prettyprint >= 0.4 && < 0.5
-                     , haskell-tools-rewrite     >= 0.4 && < 0.5
+                     , haskell-tools-ast         >= 0.5 && < 0.6
+                     , haskell-tools-prettyprint >= 0.5 && < 0.6
+                     , haskell-tools-rewrite     >= 0.5 && < 0.6
   default-language:    Haskell2010

test/Main.hs view

@@ -33,7 +33,7 @@ 
 testExprs 
   = [ ("infix", "a + 3", mkInfixApp (mkVar (mkName "a")) (mkUnqualOp "+") (mkLit $ mkIntLit 3)) 
-    , ("section", "(\"xx\"++)", mkLeftSection (mkLit (mkStringLit "xx")) (mkUnqualOp "++"))
+    , ("section", "(\"xx\" ++)", mkLeftSection (mkLit (mkStringLit "xx")) (mkUnqualOp "++"))
     , ("tuple", "(1, [2, 3])", mkTuple [ mkLit (mkIntLit 1), mkList [ mkLit (mkIntLit 2), mkLit (mkIntLit 3) ] ])
     , ("record constructor", "P { x = 1 }", mkRecCon (mkName "P") [ mkFieldUpdate (mkName "x") (mkLit $ mkIntLit 1) ])
     , ("if", "if f a then x else y"
@@ -124,12 +124,12 @@ testModules
   = [ ("empty module", "", G.mkModule [] Nothing [] [])
     , ("exports", "module Test(x, A(a), B(..)) where"
-      , G.mkModule [] (Just $ mkModuleHead (G.mkModuleName "Test") 
-          (Just $ mkExportSpecs 
+      , G.mkModule [] (Just $ mkModuleHead (G.mkModuleName "Test") Nothing 
+          (Just $ mkExportSpecs
                     [ mkExportSpec $ mkIESpec (mkName "x") Nothing
                     , mkExportSpec $ mkIESpec (mkName "A") (Just $ mkSubList [mkName "a"])
                     , mkExportSpec $ mkIESpec (mkName "B") (Just mkSubAll)
-                    ]) Nothing) [] [])
+                    ])) [] [])
     , ("imports",  "\nimport qualified A\n"
                   ++ "import B as BB(x)\n"
                   ++ "import B hiding (x)"