haskell-tools-rewrite 0.4.1.1 → 0.4.1.2

raw patch · 22 files changed

+55/−111 lines, 22 filesPVP: minor bump suggested

API additions: PVP suggests at least a minor version bump

API changes (from Hackage documentation)

+ Language.Haskell.Tools.AST.Gen.Modules: mkPatternIESpec :: Name dom -> IESpec dom

Files

Language/Haskell/Tools/AST/ElementTypes.hs +0/−1
Language/Haskell/Tools/AST/Gen.hs +6/−6
Language/Haskell/Tools/AST/Gen/Binds.hs +3/−8
Language/Haskell/Tools/AST/Gen/Decls.hs +2/−8
Language/Haskell/Tools/AST/Gen/Exprs.hs +1/−7
Language/Haskell/Tools/AST/Gen/Kinds.hs +4/−9
Language/Haskell/Tools/AST/Gen/Literals.hs +4/−10
Language/Haskell/Tools/AST/Gen/Modules.hs +7/−7
Language/Haskell/Tools/AST/Gen/Names.hs +4/−8
Language/Haskell/Tools/AST/Gen/Patterns.hs +2/−8
Language/Haskell/Tools/AST/Gen/Stmts.hs +2/−8
Language/Haskell/Tools/AST/Gen/TH.hs +2/−7
Language/Haskell/Tools/AST/Gen/Types.hs +4/−7
Language/Haskell/Tools/AST/Gen/Utils.hs +2/−3
Language/Haskell/Tools/AST/Match.hs +6/−6
Language/Haskell/Tools/AST/Match/Decls.hs +0/−1
Language/Haskell/Tools/AST/Match/Exprs.hs +0/−1
Language/Haskell/Tools/AST/Match/Literals.hs +2/−2
Language/Haskell/Tools/AST/Match/Modules.hs +1/−1
Language/Haskell/Tools/AST/Match/Patterns.hs +1/−1
Language/Haskell/Tools/AST/Rewrite.hs +1/−1
haskell-tools-rewrite.cabal +1/−1

Language/Haskell/Tools/AST/ElementTypes.hs view

@@ -1,7 +1,6 @@ module Language.Haskell.Tools.AST.ElementTypes where
 
 import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.Transform
 
 type AnnList node dom = AnnListG node dom SrcTemplateStage 
 type AnnMaybe node dom = AnnMaybeG node dom SrcTemplateStage

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

@@ -13,14 +13,14 @@   , module Language.Haskell.Tools.AST.Gen.TH
   ) where
 
-import Language.Haskell.Tools.AST.Gen.Modules
-import Language.Haskell.Tools.AST.Gen.Decls
 import Language.Haskell.Tools.AST.Gen.Binds
-import Language.Haskell.Tools.AST.Gen.Types
-import Language.Haskell.Tools.AST.Gen.Kinds
+import Language.Haskell.Tools.AST.Gen.Decls
 import Language.Haskell.Tools.AST.Gen.Exprs
-import Language.Haskell.Tools.AST.Gen.Stmts
+import Language.Haskell.Tools.AST.Gen.Kinds
 import Language.Haskell.Tools.AST.Gen.Literals
-import Language.Haskell.Tools.AST.Gen.Patterns
+import Language.Haskell.Tools.AST.Gen.Modules
 import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Patterns
+import Language.Haskell.Tools.AST.Gen.Stmts
 import Language.Haskell.Tools.AST.Gen.TH
+import Language.Haskell.Tools.AST.Gen.Types

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

@@ -6,16 +6,11 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Binds where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
+import Data.String (IsString(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Patterns
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Patterns (mkVarPat)
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList, mkAnnMaybe)
 import Language.Haskell.Tools.Transform
 
 -- | A simplified function to generate simple value bindings without local definitions, guards or complex lhs.

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

@@ -6,15 +6,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Decls where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList, mkAnnMaybe)
 import Language.Haskell.Tools.Transform
 
 -- | Creates a type synonym ( @type String = [Char]@ )
@@ -241,7 +235,7 @@                                  -> Maybe (Deriving dom) -> InstBodyDecl dom
 mkInstanceDataFamilyGADTDef keyw instRule kind cons derivs 
   = mkAnn (child <> " " <> child <> child <> child) 
-      $ UInstBodyGadtDataDecl mkDataKeyword instRule (mkAnnMaybe opt kind) (mkAnnList (after " = " $ separatedBy " | " list) cons) 
+      $ UInstBodyGadtDataDecl keyw instRule (mkAnnMaybe opt kind) (mkAnnList (after " = " $ separatedBy " | " list) cons) 
                              (mkAnnMaybe (after " deriving " opt) derivs)
 
 -- | Specialize instance pragma (no phase selection is allowed) in a type class instance

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

@@ -6,15 +6,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Exprs where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList, mkAnnMaybe)
 import Language.Haskell.Tools.Transform
 
 -- * Expressions

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

@@ -5,15 +5,10 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Kinds where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
-import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+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.Gen.Utils (mkAnn, mkAnnList)
 import Language.Haskell.Tools.Transform
 
 -- | Kind constraint (@ :: * -> * @)

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

@@ -5,16 +5,10 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Literals where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
-import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
-import Language.Haskell.Tools.Transform
+import Data.String (IsString(..), String(..))
+import Language.Haskell.Tools.AST (ULiteral(..))
+import Language.Haskell.Tools.AST.ElementTypes (Literal(..))
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn)
 
 -- | Character literal: @'c'@
 mkCharLit :: Char -> Literal dom

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

@@ -6,15 +6,11 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Modules where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
+import Data.String (IsString(..), String(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
+import Language.Haskell.Tools.AST.Gen.Names (mkStringNode)
 import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
 import Language.Haskell.Tools.Transform
 
 -- | The representation of a haskell module, that is a separate compilation unit.
@@ -44,7 +40,11 @@ 
 -- | Marks a name to be imported or exported with related names (subspecifier)
 mkIESpec :: Name dom -> Maybe (SubSpec dom) -> IESpec dom
-mkIESpec name ss = mkAnn (child <> child) (UIESpec name (mkAnnMaybe (after "(" $ followedBy ")" opt) ss))
+mkIESpec name ss = mkAnn (child <> child <> child) (UIESpec noth name (mkAnnMaybe (after "(" $ followedBy ")" opt) ss))
+
+-- | Marks a pattern synonym to be imported or exported
+mkPatternIESpec :: Name dom -> IESpec dom
+mkPatternIESpec name = mkAnn (child <> child) (UIESpec (justVal $ mkAnn child UImportPattern) name noth)
 
 -- | @(a,b,c)@: a class exported with some of its methods, or a datatype exported with some of its constructors.
 mkSubList :: [Name dom] -> SubSpec dom

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

@@ -1,20 +1,16 @@--- | Generation of basic AST fragments (names for example) for refactorings
+-- | Generation of names for refactorings
 {-# LANGUAGE OverloadedStrings
            , ViewPatterns
            , TypeFamilies
            #-}
 module Language.Haskell.Tools.AST.Gen.Names where
 
-import qualified Name as GHC
-import qualified Module as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
+import Data.String (IsString(..), String(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Utils (emptyList, mkAnn, mkAnnList)
 import Language.Haskell.Tools.Transform
+import qualified Name as GHC
 
 -- | Creates a simple, unqualified name
 mkName :: String -> Name dom

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

@@ -6,15 +6,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Patterns where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
-import Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST (UFieldWildcard(..), UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList)
 import Language.Haskell.Tools.Transform
 
 -- | Pattern name binding

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

@@ -5,15 +5,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Stmts where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
-import Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST (UCompStmt(..), UListCompBody(..), UStmt'(..))
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Utils
-import Language.Haskell.Tools.AST.Gen.Names
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList, mkAnnMaybe)
 import Language.Haskell.Tools.Transform
 
 -- | Creates a binding statement (@ x <- action @)

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

@@ -4,15 +4,10 @@            #-}
 module Language.Haskell.Tools.AST.Gen.TH where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
+import Data.String (IsString(..), String(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Names
-import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Utils (mkAnn, mkAnnList)
 import Language.Haskell.Tools.Transform
 
 -- | A simple name splice: @$generateX@

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

@@ -6,17 +6,14 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Types where
 
-import qualified Name as GHC
-import Data.List
-import Data.String
-import Data.Function (on)
-import Control.Reference
+import Data.String (IsString(..), String(..))
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Gen.Names
-import Language.Haskell.Tools.AST.Gen.Kinds
+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(..))
 
 -- * Generation of types

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

@@ -4,10 +4,9 @@            #-}
 module Language.Haskell.Tools.AST.Gen.Utils where
 
-import Control.Reference
 import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.Transform
+import Language.Haskell.Tools.AST.ElementTypes (AnnMaybe(..), AnnList(..))
+import Language.Haskell.Tools.Transform (child, opt, list)
 
 fromTemplate :: src -> NodeInfo sema src
 fromTemplate = NodeInfo (error "The newly generated AST fragments have no semantic info")

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

@@ -13,14 +13,14 @@   , module Language.Haskell.Tools.AST.Match.TH
   ) where
 
-import Language.Haskell.Tools.AST.Match.Modules
-import Language.Haskell.Tools.AST.Match.Decls
 import Language.Haskell.Tools.AST.Match.Binds
-import Language.Haskell.Tools.AST.Match.Types
-import Language.Haskell.Tools.AST.Match.Kinds
+import Language.Haskell.Tools.AST.Match.Decls
 import Language.Haskell.Tools.AST.Match.Exprs
-import Language.Haskell.Tools.AST.Match.Stmts
+import Language.Haskell.Tools.AST.Match.Kinds
 import Language.Haskell.Tools.AST.Match.Literals
-import Language.Haskell.Tools.AST.Match.Patterns
+import Language.Haskell.Tools.AST.Match.Modules
 import Language.Haskell.Tools.AST.Match.Names
+import Language.Haskell.Tools.AST.Match.Patterns
+import Language.Haskell.Tools.AST.Match.Stmts
 import Language.Haskell.Tools.AST.Match.TH
+import Language.Haskell.Tools.AST.Match.Types

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

@@ -4,7 +4,6 @@ 
 import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
-import Language.Haskell.Tools.AST.Match.Names
 
 -- WORKAROUND: nested pattern synonyms don't work in GHC 8.0, so I replaced them with longer but working pattern

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

@@ -5,7 +5,6 @@ import Language.Haskell.Tools.AST
 import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Match.Stmts
-import Language.Haskell.Tools.AST.Match.Names
 
 -- * Expressions

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

@@ -2,8 +2,8 @@ {-# LANGUAGE PatternSynonyms #-}
 module Language.Haskell.Tools.AST.Match.Literals where
 
-import Language.Haskell.Tools.AST
-import Language.Haskell.Tools.AST.ElementTypes
+import Language.Haskell.Tools.AST (ULiteral(..), Ann(..))
+import Language.Haskell.Tools.AST.ElementTypes (Literal(..))
 
 -- | Character literal: @'c'@
 pattern CharLit :: Char -> Literal dom

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

@@ -30,7 +30,7 @@ 
 -- | Marks a name to be imported or exported with related names (subspecifier)
 pattern IESpec :: Name dom -> MaybeSubSpec dom -> IESpec dom
-pattern IESpec name ss <- Ann _ (UIESpec name ss)
+pattern IESpec name ss <- Ann _ (UIESpec _ name ss)
 
 -- | @(..)@: a class exported with all of its methods, or a datatype exported with all of its constructors.
 pattern SubAll :: SubSpec dom

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

@@ -2,7 +2,7 @@ {-# LANGUAGE PatternSynonyms #-}
 module Language.Haskell.Tools.AST.Match.Patterns where
 
-import Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST (Ann(..), UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.ElementTypes
 
 -- | Pattern name binding

Language/Haskell/Tools/AST/Rewrite.hs view

@@ -7,6 +7,6 @@   , module Language.Haskell.Tools.AST.ElementTypes
   ) where
 
+import Language.Haskell.Tools.AST.ElementTypes
 import Language.Haskell.Tools.AST.Gen
 import Language.Haskell.Tools.AST.Match
-import Language.Haskell.Tools.AST.ElementTypes

haskell-tools-rewrite.cabal view

@@ -1,5 +1,5 @@ name:                haskell-tools-rewrite
-version:             0.4.1.1
+version:             0.4.1.2
 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