diff --git a/Language/Haskell/Tools/AST/Gen.hs b/Language/Haskell/Tools/AST/Gen.hs
--- a/Language/Haskell/Tools/AST/Gen.hs
+++ b/Language/Haskell/Tools/AST/Gen.hs
@@ -1,10 +1,14 @@
+-- | Public interface for the modules that generate parts of the AST
 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.Kinds as X
 import Language.Haskell.Tools.AST.Gen.Exprs as X
+import Language.Haskell.Tools.AST.Gen.Stmts as X
+import Language.Haskell.Tools.AST.Gen.Literals 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
diff --git a/Language/Haskell/Tools/AST/Gen/Base.hs b/Language/Haskell/Tools/AST/Gen/Base.hs
--- a/Language/Haskell/Tools/AST/Gen/Base.hs
+++ b/Language/Haskell/Tools/AST/Gen/Base.hs
@@ -16,6 +16,16 @@
 import Language.Haskell.Tools.AnnTrf.SourceTemplate
 import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
 
+-- | Creates a simple, unqualified name
+mkName :: String -> Ann Name dom SrcTemplateStage
+mkName = mkNormalName . mkSimpleName
+
+mkQualOp :: [String] -> String -> Ann Operator dom SrcTemplateStage
+mkQualOp quals = mkAnn child . NormalOp . mkQualifiedName quals
+
+mkBacktickOp :: [String] -> String -> Ann Operator dom SrcTemplateStage
+mkBacktickOp quals = mkAnn ("`" <> child <> "`") . BacktickOp . mkQualifiedName quals
+
 -- | Creates an annotated qualified operator: @A.B.+@ or @`A.B.mod`@.
 mkQualOp' :: [String] -> GHC.Name -> Ann Operator dom SrcTemplateStage
 mkQualOp' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ NormalOp $ mkQualifiedName' quals n
@@ -26,6 +36,9 @@
 mkUnqualOp' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ NormalOp $ mkSimpleName' n
               | otherwise                       = mkAnn ("`" <> child <> "`") $ BacktickOp $ mkSimpleName' n
   
+mkUnqualOp :: String -> Ann Operator dom SrcTemplateStage
+mkUnqualOp = mkAnn child . NormalOp . mkSimpleName
+
 -- | Creates an annotated qualified (non-operator) binding name: @A.B.f@ or @(A.B.+)@
 mkQualName' :: [String] -> GHC.Name -> Ann Name dom SrcTemplateStage
 mkQualName' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ ParenName $ mkQualifiedName' quals n
@@ -36,30 +49,43 @@
 mkUnqualName' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ ParenName $ mkSimpleName' n
                 | otherwise                       = mkAnn child $ NormalName $ mkSimpleName' n
 
-mkNormalName :: Ann SimpleName dom SrcTemplateStage -> Ann Name dom SrcTemplateStage
+mkNormalName :: Ann QualifiedName dom SrcTemplateStage -> Ann Name dom SrcTemplateStage
 mkNormalName = mkAnn child . NormalName
 
-mkParenName :: Ann SimpleName dom SrcTemplateStage -> Ann Name dom SrcTemplateStage
+mkParenName :: Ann QualifiedName dom SrcTemplateStage -> Ann Name dom SrcTemplateStage
 mkParenName = mkAnn ("(" <> child <> ")") . ParenName
 
 -- | Creates an annotated qualified simple name
-mkQualifiedName' :: [String] -> GHC.Name -> Ann SimpleName dom SrcTemplateStage
-mkQualifiedName' [] n = mkSimpleName' n
-mkQualifiedName' quals (GHC.occNameString . GHC.getOccName -> name) 
+mkQualifiedName' :: [String] -> GHC.Name -> Ann QualifiedName dom SrcTemplateStage
+mkQualifiedName' quals n = mkQualifiedName quals (GHC.occNameString $ GHC.getOccName n)
+
+mkQualifiedName :: [String] -> String -> Ann QualifiedName dom SrcTemplateStage
+mkQualifiedName [] n = mkSimpleName n
+mkQualifiedName quals name
   = mkAnn (child <> "." <> child)
-          (SimpleName (mkAnnList (listSep ".") $ map (\q -> mkAnn (fromString q) (UnqualName q)) quals) 
+          (QualifiedName (mkAnnList (listSep ".") $ map (\q -> mkAnn (fromString q) (UnqualName q)) quals) 
                       (mkAnn (fromString name) (UnqualName name)))
 
 -- | Creates an annotated part of a name.
 mkNamePart :: String -> Ann UnqualName dom SrcTemplateStage
 mkNamePart s = mkAnn (fromString s) (UnqualName s)
 
-mkSimpleName' :: GHC.Name -> Ann SimpleName dom SrcTemplateStage
+mkSimpleName' :: GHC.Name -> Ann QualifiedName dom SrcTemplateStage
 mkSimpleName' = mkSimpleName . GHC.occNameString . GHC.getOccName
 
-mkSimpleName :: String -> Ann SimpleName dom SrcTemplateStage
+mkSimpleName :: String -> Ann QualifiedName dom SrcTemplateStage
 mkSimpleName n = mkAnn (child <> child) 
-                       (SimpleName emptyList (mkAnn (fromString n) (UnqualName n)))
+                       (QualifiedName emptyList (mkAnn (fromString n) (UnqualName n)))
 
+mkStringNode :: String -> Ann StringNode dom SrcTemplateStage
+mkStringNode s = mkAnn (fromString s) (StringNode s)
+
 mkModuleName :: String -> Ann ModuleName dom SrcTemplateStage
-mkModuleName s = mkAnn (fromString s) (ModuleName s)
+mkModuleName s = mkAnn (fromString s) (ModuleName s)
+
+mkDataKeyword :: Ann DataOrNewtypeKeyword dom SrcTemplateStage
+mkDataKeyword = mkAnn "data" DataKeyword
+
+mkNewtypeKeyword :: Ann DataOrNewtypeKeyword dom SrcTemplateStage
+mkNewtypeKeyword = mkAnn "newtype" NewtypeKeyword
+
diff --git a/Language/Haskell/Tools/AST/Gen/Binds.hs b/Language/Haskell/Tools/AST/Gen/Binds.hs
--- a/Language/Haskell/Tools/AST/Gen/Binds.hs
+++ b/Language/Haskell/Tools/AST/Gen/Binds.hs
@@ -12,19 +12,23 @@
 import Data.Function (on)
 import Control.Reference
 import Language.Haskell.Tools.AST
+import Language.Haskell.Tools.AST.Gen.Patterns
 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' :: Ann Name dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann ValueBind dom SrcTemplateStage
+mkSimpleBind' n e = mkSimpleBind (mkVarPat n) (mkUnguardedRhs e) Nothing
+
 mkSimpleBind :: Ann Pattern dom SrcTemplateStage -> Ann Rhs dom SrcTemplateStage -> Maybe (Ann LocalBinds dom SrcTemplateStage) -> Ann ValueBind dom SrcTemplateStage
-mkSimpleBind p r l = mkAnn (child <> child <> child) (SimpleBind p r (mkAnnMaybe (optBefore " ") l))
+mkSimpleBind p r l = mkAnn (child <> child <> child) (SimpleBind p r (mkAnnMaybe opt l))
 
 mkFunctionBind :: [Ann Match dom SrcTemplateStage] -> Ann ValueBind dom SrcTemplateStage
 mkFunctionBind = mkAnn child . FunBind . mkAnnList indentedList
 
-mkUnguardedRhs :: Ann Expr dom SrcTemplateStage -> Ann Rhs dom SrcTemplateStage
-mkUnguardedRhs = mkAnn (" = " <> child) . UnguardedRhs
+mkFunctionBind' :: Ann Name dom SrcTemplateStage -> [([Ann Pattern dom SrcTemplateStage], Ann Expr dom SrcTemplateStage)] -> Ann ValueBind dom SrcTemplateStage
+mkFunctionBind' name matches = mkFunctionBind $ map (\(args, rhs) -> mkMatch (mkNormalMatchLhs name args) (mkUnguardedRhs rhs) Nothing) matches
 
 mkMatch :: Ann MatchLhs dom SrcTemplateStage -> Ann Rhs dom SrcTemplateStage -> Maybe (Ann LocalBinds dom SrcTemplateStage) -> Ann Match dom SrcTemplateStage
 mkMatch lhs rhs locs 
@@ -34,9 +38,57 @@
 mkNormalMatchLhs :: Ann Name dom SrcTemplateStage -> [Ann Pattern dom SrcTemplateStage] -> Ann MatchLhs dom SrcTemplateStage
 mkNormalMatchLhs n pats = mkAnn (child <> child) $ NormalLhs n (mkAnnList (listSepBefore " " " ") pats)
 
-mkLocalValBind :: Ann ValueBind dom SrcTemplateStage -> Ann LocalBind dom SrcTemplateStage
-mkLocalValBind = mkAnn child . LocalValBind
+mkInfixMatchLhs :: Ann Pattern dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage 
+                                                    -> [Ann Pattern dom SrcTemplateStage] -> Ann MatchLhs dom SrcTemplateStage
+mkInfixMatchLhs lhs op rhs pats = mkAnn (child <> child <> child <> child) $ InfixLhs lhs op rhs (mkAnnList (listSepBefore " " " ") pats)
 
 mkLocalBinds :: Int -> [Ann LocalBind dom SrcTemplateStage] -> AnnMaybe LocalBinds dom SrcTemplateStage
 mkLocalBinds col = mkAnnMaybe (optBefore ("\n" ++ replicate (col - 1) ' ' ++ "where ")) 
-                     . Just . mkAnn child . LocalBinds . mkAnnList indentedList
+                     . Just . mkAnn child . LocalBinds . mkAnnList indentedList
+
+mkLocalBinds' :: [Ann LocalBind dom SrcTemplateStage] -> Ann LocalBinds dom SrcTemplateStage
+mkLocalBinds' = mkAnn (" where " <> child) . LocalBinds . mkAnnList indentedList
+
+mkLocalValBind :: Ann ValueBind dom SrcTemplateStage -> Ann LocalBind dom SrcTemplateStage
+mkLocalValBind = mkAnn child . LocalValBind
+
+mkLocalTypeSig :: Ann TypeSignature dom SrcTemplateStage -> Ann LocalBind dom SrcTemplateStage
+mkLocalTypeSig = mkAnn child . LocalSignature
+
+mkLocalFixity :: Ann FixitySignature dom SrcTemplateStage -> Ann LocalBind dom SrcTemplateStage
+mkLocalFixity = mkAnn child . LocalFixity
+
+mkTypeSignature :: Ann Name dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann TypeSignature dom SrcTemplateStage
+mkTypeSignature n t = mkAnn (child <> " :: " <> child) (TypeSignature (mkAnnList (listSep ", ") [n]) t)
+
+mkInfixL :: Int -> Ann Operator dom SrcTemplateStage -> Ann FixitySignature dom SrcTemplateStage
+mkInfixL prec op = mkAnn (child <> " " <> child <> " " <> child) 
+                     $ FixitySignature (mkAnn "infixl" AssocLeft) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (listSep ", ") [op])
+
+mkInfixR :: Int -> Ann Operator dom SrcTemplateStage -> Ann FixitySignature dom SrcTemplateStage
+mkInfixR prec op = mkAnn (child <> " " <> child <> " " <> child) 
+                     $ FixitySignature (mkAnn "infixr" AssocRight) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (listSep ", ") [op])
+
+mkInfix :: Int -> Ann Operator dom SrcTemplateStage -> Ann FixitySignature dom SrcTemplateStage
+mkInfix prec op = mkAnn (child <> " " <> child <> " " <> child) 
+                    $ FixitySignature (mkAnn "infix" AssocNone) (mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (listSep ", ") [op])
+
+mkUnguardedRhs :: Ann Expr dom SrcTemplateStage -> Ann Rhs dom SrcTemplateStage
+mkUnguardedRhs = mkAnn (" = " <> child) . UnguardedRhs
+
+mkGuardedRhss :: [Ann GuardedRhs dom SrcTemplateStage] -> Ann Rhs dom SrcTemplateStage
+mkGuardedRhss = mkAnn child . GuardedRhss . mkAnnList indentedList
+
+mkGuardedRhs :: [Ann RhsGuard dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage -> Ann GuardedRhs dom SrcTemplateStage
+mkGuardedRhs guards expr = mkAnn ("| " <> child <> " = " <> child) $ GuardedRhs (mkAnnList (listSep ", ") guards) expr
+
+mkGuardBind :: Ann Pattern dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann RhsGuard dom SrcTemplateStage
+mkGuardBind pat expr = mkAnn (child <> " <- " <> child) $ GuardBind pat expr
+
+mkGuardLet :: [Ann LocalBind dom SrcTemplateStage] -> Ann RhsGuard dom SrcTemplateStage
+mkGuardLet = mkAnn ("let " <> child) . GuardLet . mkAnnList indentedList
+
+mkGuardCheck :: Ann Expr dom SrcTemplateStage -> Ann RhsGuard dom SrcTemplateStage
+mkGuardCheck = mkAnn child . GuardCheck
+
+-- pragmas are omitted
diff --git a/Language/Haskell/Tools/AST/Gen/Decls.hs b/Language/Haskell/Tools/AST/Gen/Decls.hs
--- a/Language/Haskell/Tools/AST/Gen/Decls.hs
+++ b/Language/Haskell/Tools/AST/Gen/Decls.hs
@@ -17,10 +17,178 @@
 import Language.Haskell.Tools.AnnTrf.SourceTemplate
 import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
 
+mkTypeDecl :: Ann DeclHead dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage 
+mkTypeDecl dh typ = mkAnn (child <> " :: " <> child) $ TypeDecl dh typ
 
-mkTypeSignature :: Ann Name dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann TypeSignature dom SrcTemplateStage
-mkTypeSignature n t = mkAnn (child <> " :: " <> child) (TypeSignature (mkAnnList (listSep ", ") [n]) t)
+mkTypeFamily :: Ann DeclHead dom SrcTemplateStage -> Maybe (Ann TypeFamilySpec dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkTypeFamily dh famSpec = mkAnn child $ TypeFamilyDecl (mkAnn (child <> child) $ TypeFamily dh (mkAnnMaybe (optBefore " ") famSpec))
 
+mkDataFamily :: Ann DeclHead dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkDataFamily dh kind = mkAnn child $ TypeFamilyDecl (mkAnn (child <> child) $ DataFamily dh (mkAnnMaybe (optBefore " ") kind))
+
+mkClosedTypeFamily :: Ann DeclHead dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage) -> [Ann TypeEqn dom SrcTemplateStage]
+                       -> Ann Decl dom SrcTemplateStage
+mkClosedTypeFamily dh kind typeqs = mkAnn (child <> child <> " where " <> child) 
+                                      $ ClosedTypeFamilyDecl dh (mkAnnMaybe (optBefore " ") kind) (mkAnnList indentedList typeqs)
+
+mkDataDecl :: Maybe (Ann Context dom SrcTemplateStage) -> Ann DeclHead dom SrcTemplateStage
+                -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkDataDecl ctx dh cons derivs 
+  = mkAnn (child <> child <> child <> child <> child) 
+      $ DataDecl (mkAnn "data " DataKeyword) (mkAnnMaybe (optBefore " ") ctx) dh 
+                 (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkNewtypeDecl :: Maybe (Ann Context dom SrcTemplateStage) -> Ann DeclHead dom SrcTemplateStage
+                   -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkNewtypeDecl ctx dh cons derivs 
+  = mkAnn (child <> child <> child <> child <> child <> child) 
+      $ DataDecl (mkAnn "newtype " NewtypeKeyword) (mkAnnMaybe (optBefore " ") ctx) dh 
+                 (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkGADTDataDecl :: Maybe (Ann Context dom SrcTemplateStage) -> Ann DeclHead dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage)
+                    -> [Ann GadtConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkGADTDataDecl ctx dh kind cons derivs 
+  = mkAnn (child <> child <> child <> child <> child <> child) 
+      $ GDataDecl (mkAnn "data " DataKeyword) (mkAnnMaybe (optBefore " ") ctx) dh 
+                  (mkAnnMaybe (optBefore " ") kind) (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkTypeInstance :: Ann InstanceRule dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage
+mkTypeInstance instRule typ = mkAnn ("type instance " <> child <> " = " <> child) $ TypeInstDecl instRule typ
+
+mkDataInstance :: Ann InstanceRule dom SrcTemplateStage -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage)
+                    -> Ann Decl dom SrcTemplateStage
+mkDataInstance instRule cons derivs 
+  = mkAnn ("data instance " <> child <> " = " <> child <> child) 
+      $ DataInstDecl (mkAnn "data " DataKeyword) instRule (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkNewtypeInstance :: Ann InstanceRule dom SrcTemplateStage -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage)
+                       -> Ann Decl dom SrcTemplateStage
+mkNewtypeInstance instRule cons derivs 
+  = mkAnn ("data instance " <> child <> " = " <> child <> child) 
+      $ DataInstDecl (mkAnn "newtype " NewtypeKeyword) instRule (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkGadtDataInstance :: Ann InstanceRule dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage) -> [Ann GadtConDecl dom SrcTemplateStage]
+                       -> Ann Decl dom SrcTemplateStage
+mkGadtDataInstance instRule kind cons 
+  = mkAnn ("data instance " <> child <> child <> " where " <> child) 
+      $ GDataInstDecl (mkAnn "data " DataKeyword) instRule (mkAnnMaybe (optBefore " ") kind) (mkAnnList indentedList cons)
+
+mkClassDecl :: Maybe (Ann Context dom SrcTemplateStage) -> Ann DeclHead dom SrcTemplateStage -> Maybe (Ann ClassBody dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkClassDecl ctx dh body = mkAnn ("class " <> child <> child <> child <> child) 
+                            $ ClassDecl (mkAnnMaybe (optAfter " ") ctx) dh (mkAnnMaybe (optBefore " | ") Nothing) (mkAnnMaybe opt body) 
+
+mkInstanceDecl :: Ann InstanceRule dom SrcTemplateStage -> Maybe (Ann InstBody dom SrcTemplateStage) -> Ann Decl dom SrcTemplateStage
+mkInstanceDecl instRule body = mkAnn ("instance " <> child <> child <> child) 
+                                 $ InstDecl (mkAnnMaybe (optBefore " ") Nothing) instRule (mkAnnMaybe opt body)
+
+mkStandaloneDeriving :: Ann InstanceRule dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage
+mkStandaloneDeriving instRule = mkAnn ("deriving instance" <> child <> child) $ DerivDecl (mkAnnMaybe (optBefore " ") Nothing) instRule
+
+mkFixityDecl :: Ann FixitySignature dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage
+mkFixityDecl = mkAnn child . FixityDecl
+
+mkTypeSigDecl :: Ann TypeSignature dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage
+mkTypeSigDecl = mkAnn child . TypeSigDecl
+
 mkValueBinding :: Ann ValueBind dom SrcTemplateStage -> Ann Decl dom SrcTemplateStage
 mkValueBinding = mkAnn child . ValueBinding
 
+mkTypeFamilyKindSpec :: Ann KindConstraint dom SrcTemplateStage -> Ann TypeFamilySpec dom SrcTemplateStage
+mkTypeFamilyKindSpec = mkAnn child . TypeFamilyKind
+
+mkTypeFamilyInjectivitySpec :: Ann Name dom SrcTemplateStage -> [Ann Name dom SrcTemplateStage] -> Ann TypeFamilySpec dom SrcTemplateStage
+mkTypeFamilyInjectivitySpec res dependent 
+  = mkAnn child (TypeFamilyInjectivity $ mkAnn (child <> " -> " <> child) $ InjectivityAnn res (mkAnnList (listSep " ") dependent))
+
+mkClassBody :: [Ann ClassElement dom SrcTemplateStage] -> Ann ClassBody dom SrcTemplateStage
+mkClassBody = mkAnn (" where " <> child) . ClassBody . mkAnnList indentedList
+
+mkClassElemSig :: Ann TypeSignature dom SrcTemplateStage -> Ann ClassElement dom SrcTemplateStage
+mkClassElemSig = mkAnn child . ClsSig
+
+mkClassElemDef :: Ann ValueBind dom SrcTemplateStage -> Ann ClassElement dom SrcTemplateStage
+mkClassElemDef = mkAnn child . ClsDef
+
+mkClassElemTypeFam :: Ann DeclHead dom SrcTemplateStage -> Maybe (Ann TypeFamilySpec dom SrcTemplateStage) -> Ann ClassElement dom SrcTemplateStage
+mkClassElemTypeFam dh tfSpec = mkAnn ("type " <> child) $ ClsTypeFam (mkAnn (child <> child) $ TypeFamily dh (mkAnnMaybe opt tfSpec))
+
+mkClassElemDataFam :: Ann DeclHead dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage) -> Ann ClassElement dom SrcTemplateStage
+mkClassElemDataFam dh kind = mkAnn ("data " <> child) $ ClsTypeFam (mkAnn (child <> child) $ DataFamily dh (mkAnnMaybe opt kind))
+
+mkNameDeclHead :: Ann Name dom SrcTemplateStage -> Ann DeclHead dom SrcTemplateStage
+mkNameDeclHead = mkAnn child . DeclHead
+
+mkParenDeclHead :: Ann DeclHead dom SrcTemplateStage -> Ann DeclHead dom SrcTemplateStage
+mkParenDeclHead = mkAnn child . DHParen
+
+mkDeclHeadApp :: Ann DeclHead dom SrcTemplateStage -> Ann TyVar dom SrcTemplateStage -> Ann DeclHead dom SrcTemplateStage
+mkDeclHeadApp dh tv = mkAnn (child <> " " <> child) $ DHApp dh tv
+
+mkInfixDeclHead :: Ann TyVar dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann TyVar dom SrcTemplateStage -> Ann DeclHead dom SrcTemplateStage
+mkInfixDeclHead lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ DHInfix lhs op rhs
+
+mkInstanceBody :: [Ann InstBodyDecl dom SrcTemplateStage] -> Ann InstBody dom SrcTemplateStage
+mkInstanceBody = mkAnn (" where " <> child) . InstBody . mkAnnList indentedList
+
+mkInstanceElemDef :: Ann ValueBind dom SrcTemplateStage -> Ann InstBodyDecl dom SrcTemplateStage
+mkInstanceElemDef = mkAnn child . InstBodyNormalDecl
+
+mkInstanceElemTypeDef :: Ann TypeEqn dom SrcTemplateStage -> Ann InstBodyDecl dom SrcTemplateStage
+mkInstanceElemTypeDef = mkAnn child . InstBodyTypeDecl
+
+mkInstanceElemDataDef :: Ann InstanceRule dom SrcTemplateStage -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage) 
+                           -> Ann InstBodyDecl dom SrcTemplateStage
+mkInstanceElemDataDef instRule cons derivs 
+  = mkAnn (child <> child <> child <> child) 
+      $ InstBodyDataDecl (mkAnn "data " DataKeyword) instRule (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkInstanceElemNewtypeDef :: Ann InstanceRule dom SrcTemplateStage -> [Ann ConDecl dom SrcTemplateStage] -> Maybe (Ann Deriving dom SrcTemplateStage) 
+                           -> Ann InstBodyDecl dom SrcTemplateStage
+mkInstanceElemNewtypeDef instRule cons derivs 
+  = mkAnn (child <> child <> child <> child) 
+      $ InstBodyDataDecl (mkAnn "newtype " NewtypeKeyword) instRule (mkAnnList (listSepBefore " | " " = ") cons) (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkInstanceElemGadtDataDef :: Ann InstanceRule dom SrcTemplateStage -> Maybe (Ann KindConstraint dom SrcTemplateStage) -> [Ann GadtConDecl dom SrcTemplateStage] 
+                               -> Maybe (Ann Deriving dom SrcTemplateStage) -> Ann InstBodyDecl dom SrcTemplateStage
+mkInstanceElemGadtDataDef instRule kind cons derivs 
+  = mkAnn (child <> child <> child <> child) 
+      $ InstBodyGadtDataDecl (mkAnn "data " DataKeyword) instRule (mkAnnMaybe opt kind) (mkAnnList (listSepBefore " | " " = ") cons) 
+                             (mkAnnMaybe (optBefore " deriving ") derivs)
+
+mkGadtConDecl :: [Ann Name dom SrcTemplateStage] -> Ann Type dom SrcTemplateStage -> Ann GadtConDecl dom SrcTemplateStage
+mkGadtConDecl names typ = mkAnn (child <> " :: " <> child) $ GadtConDecl (mkAnnList (listSep ", ") names) (mkAnn child $ GadtNormalType typ)
+
+mkConDecl :: Ann Name dom SrcTemplateStage -> [Ann Type dom SrcTemplateStage] -> Ann ConDecl dom SrcTemplateStage
+mkConDecl name args = mkAnn (child <> child) $ ConDecl name (mkAnnList (listSepBefore " " " ") args)
+
+mkRecordConDecl :: Ann Name dom SrcTemplateStage -> [Ann FieldDecl dom SrcTemplateStage] -> Ann ConDecl dom SrcTemplateStage
+mkRecordConDecl name fields = mkAnn (child <> " { " <> child <> " }") $ RecordDecl name (mkAnnList (listSep ", ") fields)
+
+mkInfixConDecl :: Ann Type dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann ConDecl dom SrcTemplateStage
+mkInfixConDecl lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ InfixConDecl lhs op rhs
+
+mkFieldDecl :: [Ann Name dom SrcTemplateStage] -> Ann Type dom SrcTemplateStage -> Ann FieldDecl dom SrcTemplateStage
+mkFieldDecl names typ = mkAnn (child <> " :: " <> child) $ FieldDecl (mkAnnList (listSep ", ") names) typ
+
+mkDeriving :: [Ann InstanceHead dom SrcTemplateStage] -> Ann Deriving dom SrcTemplateStage
+mkDeriving [deriv] = mkAnn child $ DerivingOne deriv
+mkDeriving derivs = mkAnn ("(" <> child <> ")") $ Derivings (mkAnnList (listSep ", ") derivs)
+
+mkInstanceRule :: Maybe (Ann Context dom SrcTemplateStage) -> Ann InstanceHead dom SrcTemplateStage -> Ann InstanceRule dom SrcTemplateStage
+mkInstanceRule ctx ih 
+  = mkAnn (child <> child <> child) $ InstanceRule (mkAnnMaybe (optBefore " ") Nothing) (mkAnnMaybe (optBefore " ") ctx) ih
+
+mkInstanceHead :: Ann Name dom SrcTemplateStage -> Ann InstanceHead dom SrcTemplateStage
+mkInstanceHead = mkAnn child . InstanceHeadCon
+
+mkInfixInstanceHead :: Ann Type dom SrcTemplateStage -> Ann Name dom SrcTemplateStage -> Ann InstanceHead dom SrcTemplateStage
+mkInfixInstanceHead typ n = mkAnn (child <> child) $ InstanceHeadInfix typ n
+
+mkParenInstanceHead :: Ann InstanceHead dom SrcTemplateStage -> Ann InstanceHead dom SrcTemplateStage
+mkParenInstanceHead = mkAnn ("(" <> child <> ")") . InstanceHeadParen
+
+mkAppInstanceHead :: Ann InstanceHead dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann InstanceHead dom SrcTemplateStage
+mkAppInstanceHead fun arg = mkAnn (child <> " " <> child) $ InstanceHeadApp fun arg
+
+mkTypeEqn :: Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann TypeEqn dom SrcTemplateStage
+mkTypeEqn lhs rhs = mkAnn (child <> " = " <> child) $ TypeEqn lhs rhs
diff --git a/Language/Haskell/Tools/AST/Gen/Exprs.hs b/Language/Haskell/Tools/AST/Gen/Exprs.hs
--- a/Language/Haskell/Tools/AST/Gen/Exprs.hs
+++ b/Language/Haskell/Tools/AST/Gen/Exprs.hs
@@ -17,11 +17,82 @@
 import Language.Haskell.Tools.AnnTrf.SourceTemplate
 import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
 
+mkVar :: Ann Name dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkVar = mkAnn child . Var
+
+mkLit :: Ann Literal dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkLit = mkAnn child . Lit
+
+mkInfixApp :: Ann Expr dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkInfixApp lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ InfixApp lhs op rhs
+
+mkPrefixApp :: Ann Operator dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkPrefixApp op rhs = mkAnn (child <> child) $ PrefixApp op rhs
+
 mkApp :: Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
 mkApp f e = mkAnn (child <> " " <> child) (App f e)
 
-mkVar :: Ann Name dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
-mkVar = mkAnn child . Var
+mkLambda :: [Ann Pattern dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkLambda pats rhs = mkAnn ("\\" <> child <> " -> " <> child) $ Lambda (mkAnnList (listSep " ") pats) rhs
 
+mkLet :: [Ann LocalBind dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkLet pats expr = mkAnn ("let " <> child <> " in " <> child) $ Let (mkAnnList indentedList pats) expr
+
+mkIf :: Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkIf cond then_ else_ = mkAnn ("if " <> child <> " then " <> child <> " else " <> child) $ If cond then_ else_
+
+mkMultiIf :: [Ann GuardedCaseRhs dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkMultiIf cases = mkAnn ("if" <> child) $ MultiIf (mkAnnList indentedList cases)
+
+mkCase :: Ann Expr dom SrcTemplateStage -> [Ann Alt dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkCase expr cases = mkAnn ("case " <> child <> " of " <> child) $ Case expr (mkAnnList indentedList cases)
+
+mkDoBlock :: [Ann Stmt dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkDoBlock stmts = mkAnn (child <> " " <> child) $ Do (mkAnn "do" DoKeyword) (mkAnnList indentedList stmts)
+
+mkTuple :: [Ann Expr dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkTuple exprs = mkAnn ("(" <> child <> ")") $ Tuple (mkAnnList (listSep ", ") exprs)
+
+mkUnboxedTuple :: [Ann Expr dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkUnboxedTuple exprs = mkAnn ("(# " <> child <> " #)") $ Tuple (mkAnnList (listSep ", ") exprs)
+
+mkList :: [Ann Expr dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkList exprs = mkAnn ("[" <> child <> "]") $ List (mkAnnList (listSep ", ") exprs)
+
 mkParen :: Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
 mkParen = mkAnn ("(" <> child <> ")") . Paren
+
+mkLeftSection :: Ann Expr dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkLeftSection lhs op = mkAnn ("(" <> child <> child <> ")") $ LeftSection lhs op
+
+mkRightSection :: Ann Operator dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkRightSection op rhs = mkAnn ("(" <> child <> child <> ")") $ RightSection op rhs
+
+mkRecCon :: Ann Name dom SrcTemplateStage -> [Ann FieldUpdate dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkRecCon name flds = mkAnn (child <> " { " <> child <> " }") $ RecCon name (mkAnnList (listSep ", ") flds)
+
+mkRecUpdate :: Ann Expr dom SrcTemplateStage -> [Ann FieldUpdate dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage
+mkRecUpdate expr flds = mkAnn (child <> " { " <> child <> " }") $ RecUpdate expr (mkAnnList (listSep ", ") flds)
+
+mkEnum :: Ann Expr dom SrcTemplateStage -> Maybe (Ann Expr dom SrcTemplateStage) -> Maybe (Ann Expr dom SrcTemplateStage) -> Ann Expr dom SrcTemplateStage
+mkEnum from step to = mkAnn ("[" <> child <> child <> ".." <> child <> "]") $ Enum from (mkAnnMaybe (optBefore ",") step) (mkAnnMaybe (optBefore ",") to)
+
+mkExprTypeSig :: Ann Expr dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage
+mkExprTypeSig lhs typ = mkAnn (child <> " :: " <> child) $ ExplTypeApp lhs typ
+
+mkFieldUpdate :: Ann Name dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann FieldUpdate dom SrcTemplateStage
+mkFieldUpdate name val = mkAnn (child <> " = " <> child) $ NormalFieldUpdate name val
+
+mkAlt :: Ann Pattern dom SrcTemplateStage -> Ann CaseRhs dom SrcTemplateStage -> Maybe (Ann LocalBinds dom SrcTemplateStage) -> Ann Alt dom SrcTemplateStage
+mkAlt pat rhs locals = mkAnn (child <> child <> child) $ Alt pat rhs (mkAnnMaybe (optBefore " where ") locals)
+
+mkCaseRhs :: Ann Expr dom SrcTemplateStage -> Ann CaseRhs dom SrcTemplateStage
+mkCaseRhs = mkAnn (" -> " <> child) . UnguardedCaseRhs
+
+mkGuardedCaseRhss :: [Ann GuardedCaseRhs dom SrcTemplateStage] -> Ann CaseRhs dom SrcTemplateStage
+mkGuardedCaseRhss = mkAnn child . GuardedCaseRhss . mkAnnList indentedList
+
+mkGuardedCaseRhs :: [Ann RhsGuard dom SrcTemplateStage] -> Ann Expr dom SrcTemplateStage -> Ann GuardedCaseRhs dom SrcTemplateStage
+mkGuardedCaseRhs guards expr = mkAnn (" | " <> child <> " -> " <> child) $ GuardedCaseRhs (mkAnnList (listSep ", ") guards) expr
+
+
diff --git a/Language/Haskell/Tools/AST/Gen/Kinds.hs b/Language/Haskell/Tools/AST/Gen/Kinds.hs
new file mode 100644
--- /dev/null
+++ b/Language/Haskell/Tools/AST/Gen/Kinds.hs
@@ -0,0 +1,59 @@
+-- | Generation of statement-level AST fragments for refactorings.
+-- The bindings defined here are the AST constructor names with an "mk" prefix.
+{-# LANGUAGE OverloadedStrings 
+           , TypeFamilies 
+           #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkKindConstraint :: Ann Kind dom SrcTemplateStage -> Ann KindConstraint dom SrcTemplateStage
+mkKindConstraint = mkAnn (" :: " <> child) . KindConstraint
+
+mkKindStar :: Ann Kind dom SrcTemplateStage
+mkKindStar = mkAnn "*" KindStar
+
+mkKindUnbox :: Ann Kind dom SrcTemplateStage
+mkKindUnbox = mkAnn "#" KindUnbox
+
+mkKindFun :: Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkKindFun lhs rhs = mkAnn (child <> " -> " <> child) $ KindFn lhs rhs
+
+mkKindParen :: Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkKindParen = mkAnn ("(" <> child <> ")") . KindParen
+
+mkKindVar :: Ann Name dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkKindVar = mkAnn child . KindVar
+
+mkKindApp :: Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkKindApp lhs rhs = mkAnn (child <> " " <> child) $ KindApp lhs rhs
+
+mkKindList :: Ann Kind dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkKindList = mkAnn ("[" <> child <> "]") . KindList
+
+mkIntKind :: Integer -> Ann Kind dom SrcTemplateStage
+mkIntKind i = mkAnn child $ KindPromoted $ mkAnn (fromString $ show i) (PromotedInt i)
+
+mkStringKind :: String -> Ann Kind dom SrcTemplateStage
+mkStringKind i = mkAnn child $ KindPromoted $ mkAnn (fromString $ show i) (PromotedString i)
+
+mkConKind :: Ann Name dom SrcTemplateStage -> Ann Kind dom SrcTemplateStage
+mkConKind = mkAnn child . KindPromoted . mkAnn child . PromotedCon
+
+mkListKind :: [Ann Kind dom SrcTemplateStage] -> Ann Kind dom SrcTemplateStage
+mkListKind = mkAnn child . KindPromoted . mkAnn ("[" <> child <> "]") . PromotedList . mkAnnList (listSep ", ")
+
+mkTupleKind :: [Ann Kind dom SrcTemplateStage] -> Ann Kind dom SrcTemplateStage
+mkTupleKind = mkAnn child . KindPromoted . mkAnn ("(" <> child <> ")") . PromotedTuple . mkAnnList (listSep ", ")
+
+mkUnitKind :: Ann Kind dom SrcTemplateStage
+mkUnitKind = mkAnn child $ KindPromoted $ mkAnn "()" PromotedUnit
diff --git a/Language/Haskell/Tools/AST/Gen/Literals.hs b/Language/Haskell/Tools/AST/Gen/Literals.hs
new file mode 100644
--- /dev/null
+++ b/Language/Haskell/Tools/AST/Gen/Literals.hs
@@ -0,0 +1,47 @@
+-- | Generation of literals for refactorings.
+-- The bindings defined here are the AST constructor names with an "mk" prefix.
+{-# LANGUAGE OverloadedStrings 
+           , TypeFamilies 
+           #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkCharLit :: Char -> Ann Literal dom SrcTemplateStage
+mkCharLit c = mkAnn (fromString $ show c) $ CharLit c
+
+mkStringLit :: String -> Ann Literal dom SrcTemplateStage
+mkStringLit s = mkAnn (fromString $ show s) $ StringLit s
+
+mkIntLit :: Integer -> Ann Literal dom SrcTemplateStage
+mkIntLit i = mkAnn (fromString $ show i) $ IntLit i
+
+mkFracLit :: Rational -> Ann Literal dom SrcTemplateStage
+mkFracLit f = mkAnn (fromString $ show f) $ FracLit f
+
+mkPrimIntLit :: Integer -> Ann Literal dom SrcTemplateStage
+mkPrimIntLit i = mkAnn (fromString $ show i ++ "#") $ PrimIntLit i
+
+mkPrimWordLit :: Integer -> Ann Literal dom SrcTemplateStage
+mkPrimWordLit i = mkAnn (fromString $ show i ++ "##") $ PrimWordLit i
+
+mkPrimFloatLit :: Rational -> Ann Literal dom SrcTemplateStage
+mkPrimFloatLit f = mkAnn (fromString $ show f ++ "#") $ PrimFloatLit f
+
+mkPrimDoubleLit :: Rational -> Ann Literal dom SrcTemplateStage
+mkPrimDoubleLit f = mkAnn (fromString $ show f ++ "##") $ PrimDoubleLit f
+
+mkPrimCharLit :: Char -> Ann Literal dom SrcTemplateStage
+mkPrimCharLit c = mkAnn (fromString $ show c ++ "#") $ PrimCharLit c
+
+mkPrimStringLit :: String -> Ann Literal dom SrcTemplateStage
+mkPrimStringLit s = mkAnn (fromString $ show s ++ "#") $ PrimStringLit s
diff --git a/Language/Haskell/Tools/AST/Gen/Modules.hs b/Language/Haskell/Tools/AST/Gen/Modules.hs
--- a/Language/Haskell/Tools/AST/Gen/Modules.hs
+++ b/Language/Haskell/Tools/AST/Gen/Modules.hs
@@ -20,13 +20,13 @@
 mkModule :: [Ann FilePragma dom SrcTemplateStage] -> Maybe (Ann ModuleHead dom SrcTemplateStage)
               -> [Ann ImportDecl dom SrcTemplateStage] -> [Ann Decl dom SrcTemplateStage] -> Ann Module dom SrcTemplateStage
 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)
+  = mkAnn (child <> child <> child <> child) 
+      $ Module (mkAnnList (listSepAfter "\n" "\n") filePrags) (mkAnnMaybe opt head)
+               (mkAnnList (indentedListBefore "\n") imps) (mkAnnList (indentedListBefore "\n") decls)
                
 mkModuleHead :: Ann ModuleName dom SrcTemplateStage -> Maybe (Ann ExportSpecList dom SrcTemplateStage) 
                   -> Maybe (Ann ModulePragma dom SrcTemplateStage) -> Ann ModuleHead dom SrcTemplateStage
-mkModuleHead n es pr = mkAnn (child <> child <> child) $ ModuleHead n (mkAnnMaybe (optBefore " ") es) (mkAnnMaybe opt pr)
+mkModuleHead n es pr = mkAnn ("module " <> child <> child <> child <> " where") $ ModuleHead n (mkAnnMaybe opt es) (mkAnnMaybe (optBefore "\n") pr)
 
 mkExportSpecList :: [Ann ExportSpec dom SrcTemplateStage] -> Ann ExportSpecList dom SrcTemplateStage
 mkExportSpecList = mkAnn ("(" <> child <> ")") . ExportSpecList . mkAnnList (listSep ", ")
@@ -37,9 +37,6 @@
 mkExportSpec :: Ann IESpec dom SrcTemplateStage -> Ann ExportSpec dom SrcTemplateStage
 mkExportSpec = mkAnn child . DeclExport
 
-mkImportSpecList :: [Ann IESpec dom SrcTemplateStage] -> Ann ImportSpec dom SrcTemplateStage
-mkImportSpecList = mkAnn ("(" <> child <> ")") . ImportSpecList . mkAnnList (listSep ", ")
-
 mkIeSpec :: Ann Name dom SrcTemplateStage -> Maybe (Ann SubSpec dom SrcTemplateStage) -> Ann IESpec dom SrcTemplateStage
 mkIeSpec name ss = mkAnn (child <> child) (IESpec name (mkAnnMaybe opt ss))
         
@@ -49,10 +46,8 @@
 mkSubAll :: Ann SubSpec dom SrcTemplateStage
 mkSubAll = mkAnn "(..)" SubSpecAll
 
--- TODO: mk pragmas
-
 mkImportDecl :: Bool -> Bool -> Bool -> Maybe String -> Ann ModuleName dom SrcTemplateStage 
-                     -> Maybe (Ann ImportRenaming dom SrcTemplateStage) -> Maybe (Ann ImportSpec dom SrcTemplateStage) 
+                     -> Maybe String -> Maybe (Ann ImportSpec dom SrcTemplateStage) 
                      -> Ann ImportDecl dom SrcTemplateStage       
 mkImportDecl source qualified safe pkg name rename spec
   = mkAnn ("import " <> child <> child <> child <> child <> child <> child <> child) $
@@ -60,4 +55,10 @@
                  (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)
+                 name (mkAnnMaybe opt (fmap (mkAnn (" as " <> child) . ImportRenaming . mkModuleName) rename)) (mkAnnMaybe opt spec)
+
+mkImportSpecList :: [Ann IESpec dom SrcTemplateStage] -> Ann ImportSpec dom SrcTemplateStage
+mkImportSpecList = mkAnn ("(" <> child <> ")") . ImportSpecList . mkAnnList (listSep ", ")
+
+mkImportHidingList :: [Ann IESpec dom SrcTemplateStage] -> Ann ImportSpec dom SrcTemplateStage
+mkImportHidingList = mkAnn (" hiding (" <> child <> ")") . ImportSpecHiding . mkAnnList (listSep ", ")
diff --git a/Language/Haskell/Tools/AST/Gen/Patterns.hs b/Language/Haskell/Tools/AST/Gen/Patterns.hs
--- a/Language/Haskell/Tools/AST/Gen/Patterns.hs
+++ b/Language/Haskell/Tools/AST/Gen/Patterns.hs
@@ -20,5 +20,47 @@
 mkVarPat :: Ann Name dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
 mkVarPat = mkAnn child . VarPat
 
+mkLitPat :: Ann Literal dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkLitPat = mkAnn child . LitPat
+
+mkInfixAppPat :: Ann Pattern dom SrcTemplateStage -> Ann Operator dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkInfixAppPat lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ InfixPat lhs op rhs
+
 mkAppPat :: Ann Name dom SrcTemplateStage -> [Ann Pattern dom SrcTemplateStage] -> Ann Pattern dom SrcTemplateStage
-mkAppPat n pat = mkAnn (child <> child) $ AppPat n (mkAnnList (listSepBefore " " " ") pat)
+mkAppPat n pat = mkAnn (child <> child) $ AppPat n (mkAnnList (listSepBefore " " " ") pat)
+
+mkTuplePat :: [Ann Pattern dom SrcTemplateStage] -> Ann Pattern dom SrcTemplateStage
+mkTuplePat pats = mkAnn ("(" <> child <> ")") $ TuplePat (mkAnnList (listSep ", ") pats)
+
+mkUnboxedTuplePat :: [Ann Pattern dom SrcTemplateStage] -> Ann Pattern dom SrcTemplateStage
+mkUnboxedTuplePat pats = mkAnn ("(# " <> child <> " #)") $ UnboxTuplePat (mkAnnList (listSep ", ") pats)
+
+mkListPat :: [Ann Pattern dom SrcTemplateStage] -> Ann Pattern dom SrcTemplateStage
+mkListPat pats = mkAnn ("[" <> child <> "]") $ ListPat (mkAnnList (listSep ", ") pats)
+
+mkParenPat :: Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkParenPat = mkAnn ("(" <> child <> ")") . ParenPat
+
+mkRecPat :: Ann Name dom SrcTemplateStage -> [Ann PatternField dom SrcTemplateStage] -> Ann Pattern dom SrcTemplateStage
+mkRecPat name flds = mkAnn (child <> "{ " <> child <> " }") $ RecPat name (mkAnnList (listSep ", ") flds)
+
+mkAsPat :: Ann Name dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkAsPat name pat = mkAnn (child <> "@" <> child) $ AsPat name pat
+
+mkWildPat :: Ann Pattern dom SrcTemplateStage
+mkWildPat = mkAnn "_" WildPat
+
+mkIrrefutablePat :: Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkIrrefutablePat = mkAnn ("~" <> child) . IrrPat
+
+mkBangPat :: Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkBangPat = mkAnn ("!" <> child) . BangPat
+
+mkTypeSignPat :: Ann Pattern dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkTypeSignPat pat typ = mkAnn (child <> " :: " <> child) $ TypeSigPat pat typ
+
+mkViewPat :: Ann Expr dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage
+mkViewPat name pat = mkAnn (child <> " -> " <> child) $ ViewPat name pat
+
+mkPatternField :: Ann Name dom SrcTemplateStage -> Ann Pattern dom SrcTemplateStage -> Ann PatternField dom SrcTemplateStage
+mkPatternField name pat = mkAnn (child <> " = " <> child) $ NormalFieldPattern name pat
diff --git a/Language/Haskell/Tools/AST/Gen/Stmts.hs b/Language/Haskell/Tools/AST/Gen/Stmts.hs
new file mode 100644
--- /dev/null
+++ b/Language/Haskell/Tools/AST/Gen/Stmts.hs
@@ -0,0 +1,32 @@
+-- | Generation of statement-level AST fragments for refactorings.
+-- The bindings defined here are the AST constructor names with an "mk" prefix.
+{-# LANGUAGE OverloadedStrings 
+           , TypeFamilies 
+           #-}
+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.Gen.Utils
+import Language.Haskell.Tools.AST.Gen.Base
+import Language.Haskell.Tools.AnnTrf.SourceTemplate
+import Language.Haskell.Tools.AnnTrf.SourceTemplateHelpers
+
+mkBindStmt :: Ann Pattern dom SrcTemplateStage -> Ann Expr dom SrcTemplateStage -> Ann Stmt dom SrcTemplateStage
+mkBindStmt bound expr = mkAnn (child <> " <- " <> child) $ BindStmt bound expr
+
+mkExprStmt :: Ann Expr dom SrcTemplateStage -> Ann Stmt dom SrcTemplateStage
+mkExprStmt = mkAnn child . ExprStmt
+
+mkLetStmt :: [Ann LocalBind dom SrcTemplateStage] -> Ann Stmt dom SrcTemplateStage
+mkLetStmt = mkAnn ("let " <> child) . LetStmt . mkAnnList indentedList
+
+mkListCompBody :: [Ann CompStmt dom SrcTemplateStage] -> Ann ListCompBody dom SrcTemplateStage
+mkListCompBody = mkAnn child . ListCompBody . mkAnnList (listSep " ")
+
+mkCompStmt :: Ann Stmt dom SrcTemplateStage -> Ann CompStmt dom SrcTemplateStage
+mkCompStmt = mkAnn child . CompStmt
diff --git a/Language/Haskell/Tools/AST/Gen/Types.hs b/Language/Haskell/Tools/AST/Gen/Types.hs
--- a/Language/Haskell/Tools/AST/Gen/Types.hs
+++ b/Language/Haskell/Tools/AST/Gen/Types.hs
@@ -19,11 +19,11 @@
 
 -- * Generation of types
 
-mkTyForall :: AnnList TyVar dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
-mkTyForall vars t = mkAnn ("forall " <> child <> " ." <> child <> " " <> child) (TyForall vars t)
+mkTyForall :: [Ann TyVar dom SrcTemplateStage] -> Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
+mkTyForall vars t = mkAnn ("forall " <> child <> " . " <> child) (TyForall (mkAnnList (listSep " ") vars) t)
 
-mkTypeVarList :: [GHC.Name] -> AnnList TyVar dom SrcTemplateStage
-mkTypeVarList ls = mkAnnList (listSep " ") (map (mkTypeVar . mkUnqualName') ls)
+mkTypeVar' :: GHC.Name -> Ann TyVar dom SrcTemplateStage
+mkTypeVar' = mkTypeVar . mkUnqualName'
 
 mkTyCtx :: Ann Context dom SrcTemplateStage -> Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
 mkTyCtx ctx t = mkAnn (child <> " " <> child) (TyCtx ctx t)
@@ -63,6 +63,9 @@
 
 mkTyBang :: Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
 mkTyBang = mkAnn ("!" <> child) . TyBang
+
+mkTyLazy :: Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
+mkTyLazy = mkAnn ("~" <> child) . TyLazy
 
 mkTyUnpack :: Ann Type dom SrcTemplateStage -> Ann Type dom SrcTemplateStage
 mkTyUnpack = mkAnn ("{-# UNPACK #-} " <> child) . TyUnpack
diff --git a/Language/Haskell/Tools/AST/Gen/Utils.hs b/Language/Haskell/Tools/AST/Gen/Utils.hs
--- a/Language/Haskell/Tools/AST/Gen/Utils.hs
+++ b/Language/Haskell/Tools/AST/Gen/Utils.hs
@@ -1,4 +1,4 @@
--- | Utility methods for generating parts of the ADT for refactorings
+-- | Utility methods for generating parts of the AST for refactorings
 {-# LANGUAGE FlexibleInstances
            , TypeFamilies
            #-}
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,2 +1,2 @@
-import Distribution.Simple
+import Distribution.Simple
 main = defaultMain
diff --git a/haskell-tools-ast-gen.cabal b/haskell-tools-ast-gen.cabal
--- a/haskell-tools-ast-gen.cabal
+++ b/haskell-tools-ast-gen.cabal
@@ -1,7 +1,7 @@
 name:                haskell-tools-ast-gen
-version:             0.1.3.0
+version:             0.2.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. 
+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
 license:             BSD3
 license-file:        LICENSE
@@ -13,11 +13,14 @@
 
 library
   exposed-modules:     Language.Haskell.Tools.AST.Gen
-  other-modules:       Language.Haskell.Tools.AST.Gen.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.Kinds
                      , Language.Haskell.Tools.AST.Gen.Exprs
+                     , Language.Haskell.Tools.AST.Gen.Literals
+                     , Language.Haskell.Tools.AST.Gen.Stmts
                      , Language.Haskell.Tools.AST.Gen.Patterns
                      , Language.Haskell.Tools.AST.Gen.Base
                      , Language.Haskell.Tools.AST.Gen.Utils
@@ -26,6 +29,6 @@
                      , mtl                   >=2.2   && <2.3
                      , containers            >=0.5   && <0.6
                      , references            >=0.3.2 && <1.0
-                     , haskell-tools-ast     >=0.1.3 && <0.2
-                     , haskell-tools-ast-trf >=0.1.3 && <0.2
+                     , haskell-tools-ast     >=0.2   && <0.3
+                     , haskell-tools-ast-trf >=0.2   && <0.3
   default-language:    Haskell2010