packages feed

haskell-tools-ast-gen (empty) → 0.1.2.0

raw patch · 12 files changed

+435/−0 lines, 12 filesdep +basedep +containersdep +ghcsetup-changed

Dependencies added: base, containers, ghc, haskell-tools-ast, haskell-tools-ast-trf, mtl, references, structural-traversal

Files

+ LICENSE view
@@ -0,0 +1,29 @@+Haskell-Tools is Copyright (c) Boldizsár Németh, 2016, all rights reserved,
+and is distributed as free software under the following license.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions, and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- The names of the copyright holders may not be used to endorse or
+promote products derived from this software without specific prior
+written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Language/Haskell/Tools/AST/Gen.hs view
@@ -0,0 +1,10 @@+module Language.Haskell.Tools.AST.Gen ( module X ) where
+
+import Language.Haskell.Tools.AST.Gen.Modules as X
+import Language.Haskell.Tools.AST.Gen.Decls as X
+import Language.Haskell.Tools.AST.Gen.Binds as X
+import Language.Haskell.Tools.AST.Gen.Types as X
+import Language.Haskell.Tools.AST.Gen.Exprs as X
+import Language.Haskell.Tools.AST.Gen.Patterns as X
+import Language.Haskell.Tools.AST.Gen.Base as X
+import Language.Haskell.Tools.AST.Gen.Utils as X
+ Language/Haskell/Tools/AST/Gen/Base.hs view
@@ -0,0 +1,61 @@+-- | Generation of basic AST fragments (names for example) for refactorings
+{-# LANGUAGE OverloadedStrings
+           , ViewPatterns
+           #-}
+module Language.Haskell.Tools.AST.Gen.Base 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 Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+-- | Creates an annotated qualified operator: @A.B.+@ or @`A.B.mod`@.
+mkQualOp' :: TemplateAnnot a => [String] -> GHC.Name -> Ann Operator a
+mkQualOp' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ NormalOp $ mkQualifiedName' quals n
+                  | otherwise                       = mkAnn ("`" <> child <> "`") $ BacktickOp $ mkQualifiedName' quals n
+
+-- | Creates an annotated unqualified operator: @+@ or @`mod`@.
+mkUnqualOp' :: TemplateAnnot a => GHC.Name -> Ann Operator a
+mkUnqualOp' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ NormalOp $ mkSimpleName' n
+              | otherwise                       = mkAnn ("`" <> child <> "`") $ BacktickOp $ mkSimpleName' n
+  
+-- | Creates an annotated qualified (non-operator) binding name: @A.B.f@ or @(A.B.+)@
+mkQualName' :: TemplateAnnot a => [String] -> GHC.Name -> Ann Name a
+mkQualName' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ ParenName $ mkQualifiedName' quals n
+                    | otherwise                       = mkAnn child $ NormalName $ mkQualifiedName' quals n
+
+-- | Creates an annotated unqualified (non-operator) binding name: @f@ or @(+)@
+mkUnqualName' :: TemplateAnnot a => GHC.Name -> Ann Name a
+mkUnqualName' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ ParenName $ mkSimpleName' n
+                | otherwise                       = mkAnn child $ NormalName $ mkSimpleName' n
+
+mkNormalName :: TemplateAnnot a => Ann SimpleName a -> Ann Name a
+mkNormalName = mkAnn child . NormalName
+
+mkParenName :: TemplateAnnot a => Ann SimpleName a -> Ann Name a
+mkParenName = mkAnn ("(" <> child <> ")") . ParenName
+
+-- | Creates an annotated qualified simple name
+mkQualifiedName' :: TemplateAnnot a => [String] -> GHC.Name -> Ann SimpleName a
+mkQualifiedName' [] n = mkSimpleName' n
+mkQualifiedName' quals (GHC.occNameString . GHC.getOccName -> name) 
+  = mkAnn (child <> "." <> child)
+          (SimpleName (mkAnnList (listSep ".") $ map (\q -> mkAnn (fromString q) (UnqualName q)) quals) 
+                      (mkAnn (fromString name) (UnqualName name)))
+
+-- | Creates an annotated part of a name.
+mkNamePart :: TemplateAnnot a => String -> Ann UnqualName a
+mkNamePart s = mkAnn (fromString s) (UnqualName s)
+
+mkSimpleName' :: TemplateAnnot a => GHC.Name -> Ann SimpleName a
+mkSimpleName' = mkSimpleName . GHC.occNameString . GHC.getOccName
+
+mkSimpleName :: TemplateAnnot a => String -> Ann SimpleName a
+mkSimpleName n = mkAnn (child <> child) 
+                       (SimpleName emptyList (mkAnn (fromString n) (UnqualName n)))
+ Language/Haskell/Tools/AST/Gen/Binds.hs view
@@ -0,0 +1,40 @@+-- | 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 @Match@ constructor.
+{-# LANGUAGE OverloadedStrings #-}
+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 Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkSimpleBind :: TemplateAnnot a => Ann Pattern a -> Ann Rhs a -> Maybe (Ann LocalBinds a) -> Ann ValueBind a
+mkSimpleBind p r l = mkAnn (child <> child <> child) (SimpleBind p r (mkAnnMaybe (optBefore " ") l))
+
+mkFunctionBind :: TemplateAnnot a => [Ann Match a] -> Ann ValueBind a
+mkFunctionBind = mkAnn child . FunBind . mkAnnList indentedList
+
+mkUnguardedRhs :: TemplateAnnot a => Ann Expr a -> Ann Rhs a
+mkUnguardedRhs = mkAnn (" = " <> child) . UnguardedRhs
+
+mkMatch :: TemplateAnnot a => Ann MatchLhs a -> Ann Rhs a -> Maybe (Ann LocalBinds a) -> Ann Match a
+mkMatch lhs rhs locs 
+  = mkAnn (child <> child <> child) 
+      $ Match lhs rhs (mkAnnMaybe (optBefore " ") locs)
+
+mkNormalMatchLhs :: TemplateAnnot a => Ann Name a -> [Ann Pattern a] -> Ann MatchLhs a
+mkNormalMatchLhs n pats = mkAnn (child <> child) $ NormalLhs n (mkAnnList (listSepBefore " " " ") pats)
+
+mkLocalValBind :: TemplateAnnot a => Ann ValueBind a -> Ann LocalBind a
+mkLocalValBind = mkAnn child . LocalValBind
+
+mkLocalBinds :: TemplateAnnot a => Int -> [Ann LocalBind a] -> AnnMaybe LocalBinds a
+mkLocalBinds col = mkAnnMaybe (optBefore ("\n" ++ replicate (col - 1) ' ' ++ "where ")) 
+                     . Just . mkAnn child . LocalBinds . mkAnnList indentedList
+ Language/Haskell/Tools/AST/Gen/Decls.hs view
@@ -0,0 +1,24 @@+-- | 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 @TypeSignature@ AST constructor.
+{-# LANGUAGE OverloadedStrings #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+
+mkTypeSignature :: TemplateAnnot a => Ann Name a -> Ann Type a -> Ann TypeSignature a
+mkTypeSignature n t = mkAnn (child <> " :: " <> child) (TypeSignature (mkAnnList (listSep ", ") [n]) t)
+
+mkValueBinding :: TemplateAnnot a => Ann ValueBind a -> Ann Decl a
+mkValueBinding = mkAnn child . ValueBinding
+
+ Language/Haskell/Tools/AST/Gen/Exprs.hs view
@@ -0,0 +1,25 @@+-- | 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 #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkApp :: TemplateAnnot a => Ann Expr a -> Ann Expr a -> Ann Expr a
+mkApp f e = mkAnn (child <> " " <> child) (App f e)
+
+mkVar :: TemplateAnnot a => Ann Name a -> Ann Expr a
+mkVar = mkAnn child . Var
+
+mkParen :: TemplateAnnot a => Ann Expr a -> Ann Expr a
+mkParen = mkAnn ("(" <> child <> ")") . Paren
+ Language/Haskell/Tools/AST/Gen/Modules.hs view
@@ -0,0 +1,58 @@+-- | Generation of Module-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 @Module@ AST constructor.
+{-# LANGUAGE OverloadedStrings #-}
+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 Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkModule :: TemplateAnnot a => [Ann FilePragma a] -> Maybe (Ann ModuleHead a)
+                            -> [Ann ImportDecl a] -> [Ann Decl a] -> Ann Module a
+mkModule filePrags head imps decls 
+  = mkAnn (child <> "\n" <> child <> "\n" <> child <> "\n" <> child) 
+      $ Module (mkAnnList (listSep "\n") filePrags) (mkAnnMaybe opt head)
+               (mkAnnList indentedList imps) (mkAnnList indentedList decls)
+               
+mkModuleHead :: TemplateAnnot a => Ann SimpleName a -> Maybe (Ann ExportSpecList a) -> Maybe (Ann ModulePragma a) -> Ann ModuleHead a
+mkModuleHead n es pr = mkAnn (child <> child <> child) $ ModuleHead n (mkAnnMaybe (optBefore " ") es) (mkAnnMaybe opt pr)
+
+mkExportSpecList :: TemplateAnnot a => [Ann ExportSpec a] -> Ann ExportSpecList a
+mkExportSpecList = mkAnn ("(" <> child <> ")") . ExportSpecList . mkAnnList (listSep ", ")
+
+mkModuleExport :: TemplateAnnot a => Ann SimpleName a -> Ann ExportSpec a
+mkModuleExport = mkAnn ("module " <> child) . ModuleExport
+
+mkExportSpec :: TemplateAnnot a => Ann IESpec a -> Ann ExportSpec a
+mkExportSpec = mkAnn child . DeclExport
+
+mkImportSpecList :: TemplateAnnot a => [Ann IESpec a] -> Ann ImportSpec a
+mkImportSpecList = mkAnn ("(" <> child <> ")") . ImportSpecList . mkAnnList (listSep ", ")
+
+mkIeSpec :: TemplateAnnot a => Ann Name a -> Maybe (Ann SubSpec a) -> Ann IESpec a
+mkIeSpec name ss = mkAnn (child <> child) (IESpec name (mkAnnMaybe opt ss))
+        
+mkSubList :: TemplateAnnot a => [Ann Name a] -> Ann SubSpec a
+mkSubList = mkAnn ("(" <> child <> ")") . SubSpecList . mkAnnList (listSep ", ")
+
+mkSubAll :: TemplateAnnot a => Ann SubSpec a
+mkSubAll = mkAnn "(..)" SubSpecAll
+
+-- TODO: mk pragmas
+
+mkImportDecl :: TemplateAnnot a => Bool -> Bool -> Bool -> Maybe String -> Ann SimpleName a -> Maybe (Ann ImportRenaming a) -> Maybe (Ann ImportSpec a) -> Ann ImportDecl a       
+mkImportDecl source qualified safe pkg name rename spec
+  = mkAnn ("import " <> child <> child <> child <> child <> child <> child <> child) $
+      ImportDecl (if source then justVal (mkAnn "{-# SOURCE #-} " ImportSource) else noth)
+                 (if qualified then justVal (mkAnn "qualified " ImportQualified) else noth)
+                 (if safe then justVal (mkAnn "safe " ImportSafe) else noth)
+                 (case pkg of Just str -> justVal (mkAnn (fromString $ str ++ " ") (StringNode str)); _ -> noth)
+                 name (mkAnnMaybe opt rename) (mkAnnMaybe opt spec)
+ Language/Haskell/Tools/AST/Gen/Patterns.hs view
@@ -0,0 +1,22 @@+-- | 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 #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkVarPat :: TemplateAnnot a => Ann Name a -> Ann Pattern a
+mkVarPat = mkAnn child . VarPat
+
+mkAppPat :: TemplateAnnot a => Ann Name a -> [Ann Pattern a] -> Ann Pattern a
+mkAppPat n pat = mkAnn (child <> child) $ AppPat n (mkAnnList (listSepBefore " " " ") pat)
+ Language/Haskell/Tools/AST/Gen/Types.hs view
@@ -0,0 +1,89 @@+-- | 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 #-}
+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 Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AST.Gen.Utils
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+-- * Generation of types
+
+mkTyForall :: TemplateAnnot a => AnnList TyVar a -> Ann Type a -> Ann Type a
+mkTyForall vars t = mkAnn ("forall " <> child <> " ." <> child <> " " <> child) (TyForall vars t)
+
+mkTypeVarList :: TemplateAnnot a => [GHC.Name] -> AnnList TyVar a
+mkTypeVarList ls = mkAnnList (listSep " ") (map (mkTypeVar . mkUnqualName') ls)
+
+mkTyCtx :: TemplateAnnot a => Ann Context a -> Ann Type a -> Ann Type a
+mkTyCtx ctx t = mkAnn (child <> " " <> child) (TyCtx ctx t)
+
+mkTyFun :: TemplateAnnot a => Ann Type a -> Ann Type a -> Ann Type a
+mkTyFun at rt = mkAnn (child <> " -> " <> child) (TyFun at rt)
+
+mkTyTuple :: TemplateAnnot a => [Ann Type a] -> Ann Type a
+mkTyTuple args = mkAnn ("(" <> child <> ")") (TyTuple (mkAnnList (listSep ", ") args))
+
+mkTyUnbTuple :: TemplateAnnot a => [Ann Type a] -> Ann Type a
+mkTyUnbTuple args = mkAnn ("(#" <> child <> "#)") (TyUnbTuple (mkAnnList (listSep ", ") args))
+
+mkTyList :: TemplateAnnot a => Ann Type a -> Ann Type a
+mkTyList = mkAnn ("[" <> child <> "]") . TyList
+
+mkTyParArray :: TemplateAnnot a => Ann Type a -> Ann Type a
+mkTyParArray = mkAnn ("[:" <> child <> ":]") . TyParArray
+
+mkTyApp :: TemplateAnnot a => Ann Type a -> Ann Type a -> Ann Type a
+mkTyApp ft at = mkAnn (child <> " " <> child) (TyApp ft at)
+
+mkTyInfix :: TemplateAnnot a => Ann Type a -> Ann Operator a -> Ann Type a -> Ann Type a
+mkTyInfix left op right = mkAnn (child <> " " <> child <> " " <> child) (TyInfix left op right)
+             
+mkTyParen :: TemplateAnnot a => Ann Type a -> Ann Type a
+mkTyParen = mkAnn ("(" <> child <> ")") . TyParen
+           
+mkTypeVar :: TemplateAnnot a => Ann Name a -> Ann TyVar a
+mkTypeVar n = mkAnn (child <> optBefore " ") (TyVarDecl n noth)
+
+mkTyVar :: TemplateAnnot a => Ann Name a -> Ann Type a
+mkTyVar = wrapperAnn . TyVar
+
+mkTyKinded :: TemplateAnnot a => Ann Type a -> Ann Kind a -> Ann Type a
+mkTyKinded t k = mkAnn (child <> " :: " <> child) (TyKinded t k)
+
+mkTyBang :: TemplateAnnot a => Ann Type a -> Ann Type a
+mkTyBang = mkAnn ("!" <> child) . TyBang
+
+mkTyUnpack :: TemplateAnnot a => Ann Type a -> Ann Type a
+mkTyUnpack = mkAnn ("{-# UNPACK #-} " <> child) . TyUnpack
+
+mkTyWildcard :: TemplateAnnot a => Ann Type a
+mkTyWildcard = mkAnn "_" TyWildcard
+
+mkTyNamedWildcard :: TemplateAnnot a => Ann Name a -> Ann Type a
+mkTyNamedWildcard = mkAnn ("_" <> child) . TyNamedWildc
+
+-- * Generation of contexts
+
+mkContextOne :: TemplateAnnot a => Ann Assertion a -> Ann Context a
+mkContextOne = mkAnn (child <> " =>") . ContextOne
+
+mkContextMulti :: TemplateAnnot a => [Ann Assertion a] -> Ann Context a
+mkContextMulti = mkAnn ("(" <> child <> ") =>") . ContextMulti . mkAnnList (listSep ", ")
+
+-- * Generation of assertions
+
+mkClassAssert :: TemplateAnnot a => Ann Name a -> [Ann Type a] -> Ann Assertion a
+-- fixme: class assertion without parameters should not have the last space
+mkClassAssert n args = mkAnn (child <> " " <> child) $ ClassAssert n (mkAnnList (listSep " ") args)
+
+mkInfixAssert :: TemplateAnnot a => Ann Type a -> Ann Operator a -> Ann Type a -> Ann Assertion a
+mkInfixAssert left op right = mkAnn (child <> " " <> child <> " " <> child) $ InfixAssert left op right
+ Language/Haskell/Tools/AST/Gen/Utils.hs view
@@ -0,0 +1,43 @@+-- | Utility methods for generating parts of the ADT for refactorings
+{-# LANGUAGE FlexibleInstances #-}
+module Language.Haskell.Tools.AST.Gen.Utils where
+
+import Control.Reference
+import Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+emptyList :: TemplateAnnot a => AnnList e a
+emptyList = AnnList (fromTemplate list) []
+              
+replaceWithJust :: TemplateAnnot a => Ann e a -> AnnMaybe e a -> AnnMaybe e a            
+replaceWithJust e (AnnMaybe temp _) = AnnMaybe temp (Just e)
+
+justVal :: TemplateAnnot a => Ann e a -> AnnMaybe e a
+justVal e = AnnMaybe (fromTemplate opt) (Just e)
+
+noth :: TemplateAnnot a => AnnMaybe e a
+noth = AnnMaybe (fromTemplate opt) Nothing
+
+mkAnn :: TemplateAnnot a => SourceTemplate -> e a -> Ann e a
+mkAnn temp = Ann (fromTemplate temp)
+
+-- | Annotation for a simple wrapper AST node
+wrapperAnn :: TemplateAnnot a => e a -> Ann e a
+wrapperAnn = mkAnn child
+
+-- | Transforms the list of elements to an AnnList with the given source template.
+mkAnnList :: TemplateAnnot a => SourceTemplate -> [Ann e a] -> AnnList e a
+mkAnnList temp = AnnList (fromTemplate temp)
+
+-- | Transforms the Maybe element to an AnnMaybe with the given source template.
+mkAnnMaybe :: TemplateAnnot a => SourceTemplate -> Maybe (Ann e a) -> AnnMaybe e a
+mkAnnMaybe temp = AnnMaybe (fromTemplate temp)
+  
+instance TemplateAnnot (NodeInfo (SemanticInfo n) SourceTemplate) where
+  fromTemplate = NodeInfo NoSemanticInfo
+  getTemplate = (^. sourceInfo)
+  
+instance TemplateAnnot (NodeInfo () SourceTemplate) where
+  fromTemplate = NodeInfo ()
+  getTemplate = (^. sourceInfo)
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ haskell-tools-ast-gen.cabal view
@@ -0,0 +1,32 @@+name:                haskell-tools-ast-gen
+version:             0.1.2.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. 
+homepage:            https://github.com/haskell-tools/haskell-tools
+license:             BSD3
+license-file:        LICENSE
+author:              Boldizsar Nemeth
+maintainer:          nboldi@elte.hu
+category:            Language
+build-type:          Simple
+cabal-version:       >=1.10
+
+library
+  exposed-modules:     Language.Haskell.Tools.AST.Gen
+  other-modules:       Language.Haskell.Tools.AST.Gen.Modules
+                     , Language.Haskell.Tools.AST.Gen.Decls
+                     , Language.Haskell.Tools.AST.Gen.Binds
+                     , Language.Haskell.Tools.AST.Gen.Types
+                     , Language.Haskell.Tools.AST.Gen.Exprs
+                     , Language.Haskell.Tools.AST.Gen.Patterns
+                     , Language.Haskell.Tools.AST.Gen.Base
+                     , Language.Haskell.Tools.AST.Gen.Utils
+  build-depends:       base                  >=4.9   && <5.0
+                     , ghc                   >=8.0   && <8.1
+                     , mtl                   >=2.2   && <2.3
+                     , containers            >=0.5   && <0.6
+                     , references            >=0.3.2 && <1.0
+                     , haskell-tools-ast     >=0.1.2 && <0.2
+                     , haskell-tools-ast-trf >=0.1.2 && <0.2
+                     , structural-traversal  >=0.1   && <0.2
+  default-language:    Haskell2010