haskell-tools-rewrite 0.9.0.0 → 1.0.0.0

raw patch · 18 files changed

+72/−81 lines, 18 filesdep ~basedep ~ghcdep ~haskell-tools-ast

Dependency ranges changed: base, ghc, haskell-tools-ast, haskell-tools-prettyprint

Files

Language/Haskell/Tools/Rewrite/Create/Binds.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Decls.hs +21/−20
Language/Haskell/Tools/Rewrite/Create/Exprs.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Kinds.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Literals.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Modules.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Names.hs +1/−4
Language/Haskell/Tools/Rewrite/Create/Patterns.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Stmts.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/TH.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Types.hs +1/−3
Language/Haskell/Tools/Rewrite/Create/Utils.hs +2/−4
Language/Haskell/Tools/Rewrite/ElementTypes.hs +8/−1
Language/Haskell/Tools/Rewrite/Match/Decls.hs +18/−10
Language/Haskell/Tools/Rewrite/Match/TH.hs +1/−2
Language/Haskell/Tools/Rewrite/Match/Types.hs +1/−2
haskell-tools-rewrite.cabal +8/−8
test/Main.hs +3/−3

Language/Haskell/Tools/Rewrite/Create/Binds.hs view

@@ -1,9 +1,7 @@ -- | Generation of binding-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkMatch@ creates the annotated version of the @UMatch@ constructor.
-{-# LANGUAGE OverloadedStrings
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Binds where
 
 import Data.String (IsString(..))

Language/Haskell/Tools/Rewrite/Create/Decls.hs view

@@ -1,9 +1,7 @@ -- | Generation of declaration-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkTypeSignature@ creates the annotated version of the @UTypeSignature@ AST constructor.
-{-# LANGUAGE OverloadedStrings
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Decls where
 
 import Language.Haskell.Tools.AST
@@ -16,9 +14,10 @@ mkTypeDecl dh typ = mkAnn (child <> " :: " <> child) $ UTypeDecl dh typ
 
 -- | Creates a standalone deriving declaration (@ deriving instance X T @)
-mkStandaloneDeriving :: Maybe (OverlapPragma dom) -> InstanceRule dom -> Decl dom
-mkStandaloneDeriving overlap instRule = mkAnn ("deriving instance" <> child <> child)
-                                          $ UDerivDecl (mkAnnMaybe (after " " opt) overlap) instRule
+mkStandaloneDeriving :: Maybe (DeriveStrategy dom) -> Maybe (OverlapPragma dom) -> InstanceRule dom -> Decl dom
+mkStandaloneDeriving strat overlap instRule 
+  = mkAnn ("deriving instance" <> child <> child <> child)
+      $ UDerivDecl (mkAnnMaybe (after " " opt) strat) (mkAnnMaybe (after " " opt) overlap) instRule
 
 -- | Creates a fixity declaration (@ infixl 5 +, - @)
 mkFixityDecl :: FixitySignature dom -> Decl dom
@@ -43,20 +42,20 @@ -- * Data type definitions
 
 -- | Creates a data or newtype declaration.
-mkDataDecl :: DataOrNewtypeKeyword dom -> Maybe (Context dom) -> DeclHead dom -> [ConDecl dom] -> Maybe (Deriving dom) -> Decl dom
+mkDataDecl :: DataOrNewtypeKeyword dom -> Maybe (Context dom) -> DeclHead dom -> [ConDecl dom] -> [Deriving dom] -> Decl dom
 mkDataDecl keyw ctx dh cons derivs
   = mkAnn (child <> " " <> child <> child <> child <> child)
       $ UDataDecl keyw (mkAnnMaybe (after " " opt) ctx) dh
-                 (mkAnnList (after " = " $ separatedBy " | " list) cons) (mkAnnMaybe (after " deriving " opt) derivs)
+                 (mkAnnList (after " = " $ separatedBy " | " list) cons) (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT-style data or newtype declaration.
 mkGADTDataDecl :: DataOrNewtypeKeyword dom -> Maybe (Context dom) -> DeclHead dom -> Maybe (KindConstraint dom)
-                    -> [GadtConDecl dom] -> Maybe (Deriving dom) -> Decl dom
+                    -> [GadtConDecl dom] -> [Deriving dom] -> Decl dom
 mkGADTDataDecl keyw ctx dh kind cons derivs
   = mkAnn (child <> " " <> child <> child <> child <> child <> child)
       $ UGDataDecl keyw (mkAnnMaybe (after " " opt) ctx) dh
                   (mkAnnMaybe (after " " opt) kind) (mkAnnList (after " = " $ separatedBy " | " list) cons)
-                  (mkAnnMaybe (after " deriving " opt) derivs)
+                  (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT constructor declaration (@ D1 :: Int -> T String @)
 mkGadtConDecl :: [Name dom] -> Type dom -> GadtConDecl dom
@@ -90,8 +89,8 @@ 
 -- | Creates a deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @)
 mkDeriving :: [InstanceHead dom] -> Deriving dom
-mkDeriving [deriv] = mkAnn child $ UDerivingOne deriv
-mkDeriving derivs = mkAnn ("(" <> child <> ")") $ UDerivings (mkAnnList (separatedBy ", " list) derivs)
+mkDeriving [deriv] = mkAnn (" deriving " <> child <> child) $ UDerivingOne noth deriv
+mkDeriving derivs = mkAnn (" deriving " <> child <> " (" <> child <> ")") $ UDerivings noth (mkAnnList (separatedBy ", " list) derivs)
 
 -- | The @data@ keyword in a type definition
 mkDataKeyword :: DataOrNewtypeKeyword dom
@@ -225,19 +224,19 @@ mkInstanceTypeFamilyDef = mkAnn child . UInstBodyTypeDecl
 
 -- | An associated data type implementation (@ data A X = C1 | C2 @) int a type class instance
-mkInstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> Maybe (Deriving dom) -> InstBodyDecl dom
+mkInstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> [Deriving dom] -> InstBodyDecl dom
 mkInstanceDataFamilyDef keyw instRule cons derivs
   = mkAnn (child <> " " <> child <> child <> child)
       $ UInstBodyDataDecl keyw instRule (mkAnnList (after " = " $ separatedBy " | " list) cons)
-                                        (mkAnnMaybe (after " deriving " opt) derivs)
+                                        (mkAnnList (indented list) derivs)
 
 -- | An associated data type implemented using GADT style int a type class instance
 mkInstanceDataFamilyGADTDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> Maybe (KindConstraint dom) -> [GadtConDecl dom]
-                                 -> Maybe (Deriving dom) -> InstBodyDecl dom
+                                 -> [Deriving dom] -> InstBodyDecl dom
 mkInstanceDataFamilyGADTDef keyw instRule kind cons derivs
   = mkAnn (child <> " " <> child <> child <> child)
       $ UInstBodyGadtDataDecl keyw instRule (mkAnnMaybe opt kind) (mkAnnList (after " = " $ separatedBy " | " list) cons)
-                             (mkAnnMaybe (after " deriving " opt) derivs)
+                             (mkAnnList (indented list) derivs)
 
 -- | Specialize instance pragma (no phase selection is allowed) in a type class instance
 mkInstanceSpecializePragma :: Type dom -> InstBodyDecl dom
@@ -346,11 +345,11 @@ mkTypeInstance instRule typ = mkAnn ("type instance " <> child <> " = " <> child) $ UTypeInstDecl instRule typ
 
 -- | Creates a data instance declaration (@ data instance Fam T = Con1 | Con2 @)
-mkDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> Maybe (Deriving dom) -> Decl dom
+mkDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> [Deriving dom] -> Decl dom
 mkDataInstance keyw instRule cons derivs
   = mkAnn (child <> " instance " <> child <> " = " <> child <> child)
       $ UDataInstDecl keyw instRule (mkAnnList (after " = " $ separatedBy " | " list) cons)
-                                    (mkAnnMaybe (after " deriving " opt) derivs)
+                                    (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT-style data instance declaration (@ data instance Fam T where ... @)
 mkGadtDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> Maybe (KindConstraint dom) -> [GadtConDecl dom] -> Decl dom
@@ -395,8 +394,10 @@ mkPatternSignatureDecl :: PatternSignature dom -> Decl dom
 mkPatternSignatureDecl = mkAnn child . UPatTypeSigDecl
 
-mkPatternSignature :: Name dom -> Type dom -> PatternSignature dom
-mkPatternSignature name typ = mkAnn (child <> " :: " <> child) $ UPatternTypeSignature name typ
+mkPatternSignature :: [Name dom] -> Type dom -> PatternSignature dom
+mkPatternSignature names typ
+  = mkAnn (child <> " :: " <> child)
+      $ UPatternTypeSignature (mkAnnList (separatedBy ", " list) names) typ
 
 -- * Top level pragmas

Language/Haskell/Tools/Rewrite/Create/Exprs.hs view

@@ -1,9 +1,7 @@ -- | Generation of expression-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkApp@ creates the annotated version of the @App@ AST constructor.
-{-# LANGUAGE OverloadedStrings 
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Exprs where
 
 import Language.Haskell.Tools.AST

Language/Haskell/Tools/Rewrite/Create/Kinds.hs view

@@ -1,8 +1,6 @@ -- | Generation of statement-level AST fragments for refactorings.
 -- The bindings defined here are the AST constructor names with an "mk" prefix.
-{-# LANGUAGE OverloadedStrings 
-           , TypeFamilies 
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Kinds where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Literals.hs view

@@ -1,8 +1,6 @@ -- | Generation of literals for refactorings.
 -- The bindings defined here are the AST constructor names with an "mk" prefix.
-{-# LANGUAGE OverloadedStrings 
-           , TypeFamilies 
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Literals where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Modules.hs view

@@ -1,9 +1,7 @@ -- | Generation of UModule-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkModule@ creates the annotated version of the @UModule@ AST constructor.
-{-# LANGUAGE OverloadedStrings
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Modules where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Names.hs view

@@ -1,8 +1,5 @@ -- | Generation of names for refactorings
-{-# LANGUAGE OverloadedStrings
-           , ViewPatterns
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Names where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Patterns.hs view

@@ -1,9 +1,7 @@ -- | Generation of pattern-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkVarPat@ creates the annotated version of the @VarPat@ AST constructor.
-{-# LANGUAGE OverloadedStrings 
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Patterns where
 
 import Language.Haskell.Tools.AST (UFieldWildcard(..), UPatternField(..), UPattern(..))

Language/Haskell/Tools/Rewrite/Create/Stmts.hs view

@@ -1,8 +1,6 @@ -- | Generation of statement-level AST fragments for refactorings.
 -- The bindings defined here are the AST constructor names with an "mk" prefix.
-{-# LANGUAGE OverloadedStrings 
-           , TypeFamilies 
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Stmts where
 
 import Language.Haskell.Tools.AST (UCompStmt(..), UListCompBody(..), UStmt'(..))

Language/Haskell/Tools/Rewrite/Create/TH.hs view

@@ -1,7 +1,5 @@ -- | Generation of Template Haskell AST fragments for refactorings.
-{-# LANGUAGE OverloadedStrings
-           , TypeFamilies 
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.TH where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Types.hs view

@@ -1,9 +1,7 @@ -- | Generation of type-level AST fragments for refactorings.
 -- The bindings defined here create a the annotated version of the AST constructor with the same name.
 -- For example, @mkTyForall@ creates the annotated version of the @TyForall@ AST constructor.
-{-# LANGUAGE OverloadedStrings
-           , TypeFamilies
-           #-}
+{-# LANGUAGE OverloadedStrings, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Types where
 
 import Data.String (IsString(..), String)

Language/Haskell/Tools/Rewrite/Create/Utils.hs view

@@ -1,7 +1,5 @@ -- | Utility methods for generating parts of the AST for refactorings
-{-# LANGUAGE FlexibleInstances
-           , TypeFamilies
-           #-}
+{-# LANGUAGE FlexibleInstances, TypeFamilies #-}
 module Language.Haskell.Tools.Rewrite.Create.Utils where
 
 import Language.Haskell.Tools.AST
@@ -9,7 +7,7 @@ import Language.Haskell.Tools.Rewrite.ElementTypes (AnnMaybe, AnnList)
 
 fromTemplate :: src -> NodeInfo sema src
-fromTemplate = NodeInfo (error "The newly generated AST fragments have no semantic info")
+fromTemplate = NodeInfo (error "The newly generated AST fragments have no semantic info, but a refactoring tries to use that information.")
 
 emptyList :: AnnList e dom
 emptyList = AnnListG (fromTemplate list) []

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

@@ -106,12 +106,18 @@ -- | A deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @)
 type Deriving dom = Ann UDeriving dom SrcTemplateStage
 
+-- | A deriving strategy (@stock@, @newtype@ or @anyclass@)
+type DeriveStrategy dom = Ann UDeriveStrategy dom SrcTemplateStage
+
 -- | The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword.
 type InstanceRule dom = Ann UInstanceRule dom SrcTemplateStage
 
 -- | The specification of the class instance declaration
 type InstanceHead dom = Ann UInstanceHead dom SrcTemplateStage
 
+-- | Specialize pragma (@ {-# SPECIALISE f :: Int -> b -> b #-} @)
+type SpecializePragma dom = Ann USpecializePragma dom SrcTemplateStage
+
 -- | Overlap pragmas. Can be applied to class declarations and class instance declarations.
 type OverlapPragma dom = Ann UOverlapPragma dom SrcTemplateStage
 
@@ -207,7 +213,6 @@ -- | A type signature (@ f :: Int -> Int @)
 type TypeSignature dom = Ann UTypeSignature dom SrcTemplateStage
 
-
 -- * Types
 
 -- | Haskell types
@@ -328,6 +333,7 @@ 
 type MaybeContext dom = AnnMaybe UContext dom
 type MaybeDeriving dom = AnnMaybe UDeriving dom
+type MaybeDeriveStrategy dom = AnnMaybe UDeriveStrategy dom
 type MaybeLocalBinds dom = AnnMaybe ULocalBinds dom
 type MaybeTypeFamilySpec dom = AnnMaybe UTypeFamilySpec dom
 type MaybeKindConstraint dom = AnnMaybe UKindConstraint dom
@@ -395,3 +401,4 @@ type LanguageExtensionList dom = AnnList ULanguageExtension dom
 type StringNodeList dom = AnnList UStringNode dom
 type NamePartList dom = AnnList UNamePart dom
+type DerivingList dom = AnnList UDeriving dom

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

@@ -14,8 +14,8 @@ pattern TypeDecl dh typ <- Ann _ (UTypeDecl dh typ)
 
 -- | Standalone deriving declaration (@ deriving instance X T @)
-pattern StandaloneDeriving :: InstanceRule dom -> Decl dom
-pattern StandaloneDeriving instRule <- Ann _ (UDerivDecl _ instRule)
+pattern StandaloneDeriving :: Maybe (DeriveStrategy dom) -> Maybe (OverlapPragma dom) -> InstanceRule dom -> Decl dom
+pattern StandaloneDeriving strat overlap instRule <- Ann _ (UDerivDecl (AnnMaybeG _ strat) (AnnMaybeG _ overlap) instRule)
 
 -- | Fixity declaration (@ infixl 5 +, - @)
 pattern FixityDecl :: FixitySignature dom -> Decl dom
@@ -41,11 +41,11 @@ 
 -- | A data or newtype declaration. Empty data type declarations without
 -- where keyword are always belong to DataDecl.
-pattern DataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> ConDeclList dom -> MaybeDeriving dom -> Decl dom
+pattern DataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> ConDeclList dom -> DerivingList dom -> Decl dom
 pattern DataDecl keyw ctx dh cons derivs <- Ann _ (UDataDecl keyw ctx dh cons derivs)
 
 -- | A GADT-style data or newtype declaration.
-pattern GADTDataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage -> MaybeDeriving dom -> Decl dom
+pattern GADTDataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage -> DerivingList dom -> Decl dom
 pattern GADTDataDecl keyw ctx dh kind cons derivs  <- Ann _ (UGDataDecl keyw ctx dh kind cons derivs )
 
 -- | GADT constructor declaration (@ D1 :: Int -> T String @)
@@ -74,12 +74,20 @@ 
 -- | A deriving clause without parentheses (@ deriving Show @.
 pattern DerivingOne :: InstanceHead dom -> Deriving dom
-pattern DerivingOne deriv <- Ann _ (UDerivingOne deriv)
+pattern DerivingOne deriv <- Ann _ (UDerivingOne _ deriv)
 
+-- | A deriving clause without parentheses, with/witohut strategy (@ deriving stock Show @.
+pattern DerivingOne' :: MaybeDeriveStrategy dom -> InstanceHead dom -> Deriving dom
+pattern DerivingOne' strat deriv <- Ann _ (UDerivingOne strat deriv)
+
 -- | A deriving clause with parentheses @ deriving (Show, Eq) @)
 pattern DerivingMulti :: InstanceHeadList dom -> Deriving dom
-pattern DerivingMulti derivs <- Ann _ (UDerivings derivs)
+pattern DerivingMulti derivs <- Ann _ (UDerivings _ derivs)
 
+-- | A deriving clause with parentheses, with/witohut strategy (@ deriving stock (Show, Eq) @.
+pattern DerivingMulti' :: MaybeDeriveStrategy dom -> InstanceHeadList dom -> Deriving dom
+pattern DerivingMulti' strat derivs <- Ann _ (UDerivings strat derivs)
+
 pattern DataKeyword :: DataOrNewtypeKeyword dom
 pattern DataKeyword <- Ann _ UDataKeyword
 
@@ -187,12 +195,12 @@ pattern InstanceTypeFamilyDef typeEq <- Ann _ (UInstBodyTypeDecl typeEq)
 
 -- | An associated data definition (@ data A X = B Int | C @) in a class instance
-pattern InstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> MaybeDeriving dom -> InstBodyDecl dom
+pattern InstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> DerivingList dom -> InstBodyDecl dom
 pattern InstanceDataFamilyDef keyw instRule cons derivs  <- Ann _ (UInstBodyDataDecl keyw instRule cons derivs )
 
 -- | An associated data definition as a GADT (@ data A X where B :: Int -> A X @) in a class instance
 pattern InstanceDataFamilyGADTDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage
-                                       -> MaybeDeriving dom -> InstBodyDecl dom
+                                       -> DerivingList dom -> InstBodyDecl dom
 pattern InstanceDataFamilyGADTDef keyw instRule kind cons derivs <- Ann _ (UInstBodyGadtDataDecl keyw instRule kind cons derivs)
 
 -- | Specialize instance pragma in a class instance  (no phase selection is allowed)
@@ -318,7 +326,7 @@ pattern PatternSignatureDecl :: PatternSignature dom -> Decl dom
 pattern PatternSignatureDecl patsig <- Ann _ (UPatTypeSigDecl patsig)
 
-pattern PatternSignature :: Name dom -> Type dom -> PatternSignature dom
+pattern PatternSignature :: NameList dom -> Type dom -> PatternSignature dom
 pattern PatternSignature name typ <- Ann _ (UPatternTypeSignature name typ)
 
 -- * Type families
@@ -336,7 +344,7 @@ pattern TypeInstance instRule typ <- Ann _ (UTypeInstDecl instRule typ)
 
 -- | Data instance declaration (@ data instance Fam T = Con1 | Con2 @)
-pattern DataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> MaybeDeriving dom -> Decl dom
+pattern DataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> DerivingList dom -> Decl dom
 pattern DataInstance keyw instRule cons derivs  <- Ann _ (UDataInstDecl keyw instRule cons derivs )
 
 -- | GADT-style data instance declaration (@ data instance Fam T where ... @)

Language/Haskell/Tools/Rewrite/Match/TH.hs view

@@ -1,6 +1,5 @@ -- | Pattern matching on Template Haskell AST fragments for refactorings.
-{-# LANGUAGE PatternSynonyms
-           #-}
+{-# LANGUAGE PatternSynonyms #-}
 module Language.Haskell.Tools.Rewrite.Match.TH where
 
 import Language.Haskell.Tools.AST

Language/Haskell/Tools/Rewrite/Match/Types.hs view

@@ -1,6 +1,5 @@ -- | UPattern matching on type-level AST fragments for refactorings.
-{-# LANGUAGE PatternSynonyms
-           #-}
+{-# LANGUAGE PatternSynonyms #-}
 module Language.Haskell.Tools.Rewrite.Match.Types where
 
 import Language.Haskell.Tools.AST

haskell-tools-rewrite.cabal view

@@ -1,5 +1,5 @@ name:                haskell-tools-rewrite
-version:             0.9.0.0
+version:             1.0.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
@@ -39,13 +39,13 @@                      , Language.Haskell.Tools.Rewrite.Match.Names
                      , Language.Haskell.Tools.Rewrite.Match.TH
   other-modules:       Language.Haskell.Tools.Rewrite.Create.Utils
-  build-depends:       base                      >= 4.9  && < 4.10
+  build-depends:       base                      >= 4.10  && < 4.11
                      , mtl                       >= 2.2  && < 2.3
                      , containers                >= 0.5  && < 0.6
                      , references                >= 0.3  && < 0.4
-                     , ghc                       >= 8.0  && < 8.1
-                     , haskell-tools-ast         >= 0.9  && < 0.10
-                     , haskell-tools-prettyprint >= 0.9  && < 0.10
+                     , ghc                       >= 8.2  && < 8.3
+                     , haskell-tools-ast         >= 1.0  && < 1.1
+                     , haskell-tools-prettyprint >= 1.0  && < 1.1
   default-language:    Haskell2010
 
 test-suite haskell-tools-rewrite-tests
@@ -53,12 +53,12 @@   ghc-options:         -with-rtsopts=-M2g
   hs-source-dirs:      test
   main-is:             Main.hs
-  build-depends:       base                      >= 4.9 && < 4.10
+  build-depends:       base                      >= 4.10 && < 4.11
                      , tasty                     >= 0.11 && < 0.12
                      , tasty-hunit               >= 0.9 && < 0.10
                      , directory                 >= 1.2 && < 1.4
                      , filepath                  >= 1.4 && < 2.0
-                     , haskell-tools-ast         >= 0.9 && < 0.10
-                     , haskell-tools-prettyprint >= 0.9 && < 0.10
+                     , haskell-tools-ast         >= 1.0 && < 1.1
+                     , haskell-tools-prettyprint >= 1.0 && < 1.1
                      , haskell-tools-rewrite
   default-language:    Haskell2010

test/Main.hs view

@@ -101,13 +101,13 @@       , mkValueBinding $ mkFunctionBind' (mkName "id") [([mkVarPat $ mkName "x"], mkVar $ mkName "x")])
     , ("datatype definition", "data A a = A a deriving Show"
       , mkDataDecl mkDataKeyword Nothing (mkDeclHeadApp (mkNameDeclHead (mkName "A")) (mkTypeVar (mkName "a")))
-          [mkConDecl (mkName "A") [mkVarType (mkName "a")]] (Just $ mkDeriving [mkInstanceHead (mkName "Show")]))
+          [mkConDecl (mkName "A") [mkVarType (mkName "a")]] [mkDeriving [mkInstanceHead (mkName "Show")]])
     , ("record definition", "data A = A { x :: Int }"
       , mkDataDecl mkDataKeyword Nothing (mkNameDeclHead (mkName "A"))
-          [mkRecordConDecl (mkName "A") [mkFieldDecl [mkName "x"] (mkVarType (mkName "Int"))]] Nothing)
+          [mkRecordConDecl (mkName "A") [mkFieldDecl [mkName "x"] (mkVarType (mkName "Int"))]] [])
     , ("typeclass definition",    "class A t => C t where f :: t\n"
                                ++ "                       type T t :: *"
-      , mkClassDecl (Just $ mkContext (mkClassAssert (mkName "A") [mkVarType (mkName "t")])) 
+      , mkClassDecl (Just $ mkContext (mkClassAssert (mkName "A") [mkVarType (mkName "t")]))
                     (mkDeclHeadApp (mkNameDeclHead (mkName "C")) (mkTypeVar (mkName "t"))) []
                     (Just $ mkClassBody [ mkClassElemSig $ mkTypeSignature (mkName "f") (mkVarType (mkName "t"))
                                         , mkClassElemTypeFam (mkDeclHeadApp (mkNameDeclHead (mkName "T"))