diff --git a/Language/Haskell/Tools/AST.hs b/Language/Haskell/Tools/AST.hs
--- a/Language/Haskell/Tools/AST.hs
+++ b/Language/Haskell/Tools/AST.hs
@@ -2,26 +2,39 @@
 -- Different layers of the AST are recursive, to separate them into modules
 -- we introduced source imports.
 module Language.Haskell.Tools.AST 
-  ( module Exported
+  ( module Language.Haskell.Tools.AST.References
+  , module Language.Haskell.Tools.AST.Helpers
+  , module Language.Haskell.Tools.AST.Representation.Modules
+  , module Language.Haskell.Tools.AST.Representation.TH
+  , module Language.Haskell.Tools.AST.Representation.Decls
+  , module Language.Haskell.Tools.AST.Representation.Binds
+  , module Language.Haskell.Tools.AST.Representation.Exprs
+  , module Language.Haskell.Tools.AST.Representation.Stmts
+  , module Language.Haskell.Tools.AST.Representation.Patterns
+  , module Language.Haskell.Tools.AST.Representation.Types
+  , module Language.Haskell.Tools.AST.Representation.Kinds
+  , module Language.Haskell.Tools.AST.Representation.Literals
+  , module Language.Haskell.Tools.AST.Representation.Names
+  , module Language.Haskell.Tools.AST.Ann
+  , module Language.Haskell.Tools.AST.Utils.OrdSrcSpan
+  , module Language.Haskell.Tools.AST.SemaInfoClasses
   ) where
 
-import Language.Haskell.Tools.AST.Instances
-
-import Language.Haskell.Tools.AST.References as Exported
-import Language.Haskell.Tools.AST.Helpers as Exported
+import Language.Haskell.Tools.AST.Instances ()
 
-import Language.Haskell.Tools.AST.Representation.Modules as Exported
-import Language.Haskell.Tools.AST.Representation.TH as Exported
-import Language.Haskell.Tools.AST.Representation.Decls as Exported
-import Language.Haskell.Tools.AST.Representation.Binds as Exported
-import Language.Haskell.Tools.AST.Representation.Exprs as Exported
-import Language.Haskell.Tools.AST.Representation.Stmts as Exported
-import Language.Haskell.Tools.AST.Representation.Patterns as Exported
-import Language.Haskell.Tools.AST.Representation.Types as Exported
-import Language.Haskell.Tools.AST.Representation.Kinds as Exported
-import Language.Haskell.Tools.AST.Representation.Literals as Exported
-import Language.Haskell.Tools.AST.Representation.Names as Exported
-import Language.Haskell.Tools.AST.Ann as Exported
-import Language.Haskell.Tools.AST.Utils.OrdSrcSpan as Exported
-import Language.Haskell.Tools.AST.SemaInfoClasses as Exported
--- import Language.Haskell.Tools.AST.SemaInfoTypes (NoSemanticInfo, ScopeInfo, NameInfo, ) as Exported
+import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Helpers
+import Language.Haskell.Tools.AST.References
+import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Kinds
+import Language.Haskell.Tools.AST.Representation.Literals
+import Language.Haskell.Tools.AST.Representation.Modules
+import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.Stmts
+import Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Representation.Types
+import Language.Haskell.Tools.AST.SemaInfoClasses
+import Language.Haskell.Tools.AST.Utils.OrdSrcSpan
diff --git a/Language/Haskell/Tools/AST/Ann.hs b/Language/Haskell/Tools/AST/Ann.hs
--- a/Language/Haskell/Tools/AST/Ann.hs
+++ b/Language/Haskell/Tools/AST/Ann.hs
@@ -15,22 +15,17 @@
 -- | Parts of AST representation for keeping extra data
 module Language.Haskell.Tools.AST.Ann where
 
-import Data.Data
-import Control.Monad.Identity
 import Control.Reference
-import SrcLoc as GHC
+import Data.Data
 import Id as GHC
-import qualified Name as GHC
-import RdrName
-import Module
-import Id
-import Outputable
-import Language.Haskell.Tools.AST.Utils.GHCInstances
 import Language.Haskell.Tools.AST.SemaInfoTypes
+import Language.Haskell.Tools.AST.Utils.GHCInstances ()
+import qualified Name as GHC
+import SrcLoc as GHC
 
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs as AST
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Modules as AST
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Names as AST
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs as AST
 
 -- * Annotation type resolution
 
@@ -277,7 +272,6 @@
         
 makeReferences ''Ann
 
-
 -- | A list of AST elements
 data AnnListG elem dom stage = AnnListG { _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage) 
                                         , _annListElems :: [Ann elem dom stage]
@@ -294,6 +288,22 @@
                                           }
                              
 makeReferences ''AnnMaybeG
+
+class HasSourceInfo e where
+  type SourceInfoType e :: *
+  srcInfo :: Simple Lens e (SourceInfoType e)
+
+instance HasSourceInfo (Ann elem dom stage) where
+  type SourceInfoType (Ann elem dom stage) = SpanInfo stage
+  srcInfo = annotation & sourceInfo
+
+instance HasSourceInfo (AnnListG elem dom stage) where
+  type SourceInfoType (AnnListG elem dom stage) = ListInfo stage
+  srcInfo = annListAnnot & sourceInfo
+
+instance HasSourceInfo (AnnMaybeG elem dom stage) where
+  type SourceInfoType (AnnMaybeG elem dom stage) = OptionalInfo stage
+  srcInfo = annMaybeAnnot & sourceInfo
                           
 annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s)                          
 annJust = annMaybe & just
diff --git a/Language/Haskell/Tools/AST/Helpers.hs b/Language/Haskell/Tools/AST/Helpers.hs
--- a/Language/Haskell/Tools/AST/Helpers.hs
+++ b/Language/Haskell/Tools/AST/Helpers.hs
@@ -11,36 +11,31 @@
 -- | Helper functions for using the AST.
 module Language.Haskell.Tools.AST.Helpers where
 
+import qualified Name as GHC (Name(..))
 import SrcLoc
-import qualified Name as GHC
 
 import Control.Reference
-import Control.Monad
-import Data.List
-import Data.Maybe
-import Data.Function hiding ((&))
-import Data.Generics.Uniplate.Operations
+import Data.Function (($), (.), on)
+import Data.Generics.Uniplate.Operations (Biplate(..))
+import Data.List (elem, any, minimumBy)
+import Data.Maybe (Maybe(..), isJust)
 
 import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.Decls
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Binds
-import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Names
 import Language.Haskell.Tools.AST.References
-import Language.Haskell.Tools.AST.SemaInfoTypes
-import Language.Haskell.Tools.AST.SemaInfoClasses
-
-import Debug.Trace
+import Language.Haskell.Tools.AST.Representation.Binds (ULocalBind(..), UValueBind(..))
+import Language.Haskell.Tools.AST.Representation.Decls (UDeclHead(..), UDecl(..))
+import Language.Haskell.Tools.AST.Representation.Modules (UImportDecl(..))
+import Language.Haskell.Tools.AST.Representation.Names (UQualifiedName(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Types (UType(..))
+import Language.Haskell.Tools.AST.SemaInfoTypes (Scope(..))
  
 -- | Does the import declaration import only the explicitly listed elements?
 importIsExact :: Ann UImportDecl dom stage -> Bool
 importIsExact = isJust . (^? importSpec&annJust&importSpecList)  
 
 -- | Accesses the name of a function or value binding
-bindingName :: (SemanticInfo dom UQualifiedName ~ ni) => Simple Traversal (Ann UValueBind dom stage) (Ann UQualifiedName dom stage)
+bindingName :: Simple Traversal (Ann UValueBind dom stage) (Ann UQualifiedName dom stage)
 bindingName = (valBindPat&patternName&simpleName 
                         &+& funBindMatches&annList&matchLhs
                               &(matchLhsName&simpleName &+& matchLhsOperator&operatorName))
@@ -67,7 +62,7 @@
 semantics = annotation&semanticInfo
 
 -- | Get all nodes that contain a given source range
-nodesContaining :: (HasRange (inner dom stage), Biplate (node dom stage) (inner dom stage), SourceInfo stage) 
+nodesContaining :: (HasRange (inner dom stage), Biplate (node dom stage) (inner dom stage)) 
                 => RealSrcSpan -> Simple Traversal (node dom stage) (inner dom stage)
 nodesContaining rng = biplateRef & filtered (isInside rng) 
 
@@ -77,7 +72,7 @@
                                       _              -> False
 
 -- | Get all nodes that are contained in a given source range
-nodesContained :: (HasRange (inner dom stage), Biplate (node dom stage) (inner dom stage), SourceInfo stage) 
+nodesContained :: (HasRange (inner dom stage), Biplate (node dom stage) (inner dom stage)) 
                     => RealSrcSpan -> Simple Traversal (node dom stage) (inner dom stage)
 nodesContained rng = biplateRef & filtered (isContained rng) 
 
diff --git a/Language/Haskell/Tools/AST/Instances.hs b/Language/Haskell/Tools/AST/Instances.hs
--- a/Language/Haskell/Tools/AST/Instances.hs
+++ b/Language/Haskell/Tools/AST/Instances.hs
@@ -1,9 +1,9 @@
 -- | All derived instances for AST elements
 module Language.Haskell.Tools.AST.Instances where
 
-import Language.Haskell.Tools.AST.Instances.Data
-import Language.Haskell.Tools.AST.Instances.Eq
-import Language.Haskell.Tools.AST.Instances.Show
-import Language.Haskell.Tools.AST.Instances.Generic
-import Language.Haskell.Tools.AST.Instances.SourceInfoTraversal
-import Language.Haskell.Tools.AST.Instances.SemanticTraversal
+import Language.Haskell.Tools.AST.Instances.Data ()
+import Language.Haskell.Tools.AST.Instances.Eq ()
+import Language.Haskell.Tools.AST.Instances.Generic ()
+import Language.Haskell.Tools.AST.Instances.SemanticTraversal ()
+import Language.Haskell.Tools.AST.Instances.Show ()
+import Language.Haskell.Tools.AST.Instances.SourceInfoTraversal ()
diff --git a/Language/Haskell/Tools/AST/Instances/Data.hs b/Language/Haskell/Tools/AST/Instances/Data.hs
--- a/Language/Haskell/Tools/AST/Instances/Data.hs
+++ b/Language/Haskell/Tools/AST/Instances/Data.hs
@@ -2,20 +2,20 @@
 {-# LANGUAGE FlexibleContexts, StandaloneDeriving, DeriveDataTypeable #-}
 module Language.Haskell.Tools.AST.Instances.Data where
 
-import Data.Data
+import Data.Data (Data(..), Typeable(..))
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Modules
+import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Representation.Patterns (UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.TH
 import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Kinds
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
 
 -- Annotations
 deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (Ann e dom stage)
@@ -33,6 +33,7 @@
 deriving instance (Domain dom, SourceInfo stage) => Data (UFilePragma dom stage)
 deriving instance (Domain dom, SourceInfo stage) => Data (UImportDecl dom stage)
 deriving instance (Domain dom, SourceInfo stage) => Data (UImportSpec dom stage)
+deriving instance (Domain dom, SourceInfo stage) => Data (UImportModifier dom stage)
 deriving instance (Domain dom, SourceInfo stage) => Data (UImportQualified dom stage)
 deriving instance (Domain dom, SourceInfo stage) => Data (UImportSource dom stage)
 deriving instance (Domain dom, SourceInfo stage) => Data (UImportSafe dom stage)
diff --git a/Language/Haskell/Tools/AST/Instances/Eq.hs b/Language/Haskell/Tools/AST/Instances/Eq.hs
--- a/Language/Haskell/Tools/AST/Instances/Eq.hs
+++ b/Language/Haskell/Tools/AST/Instances/Eq.hs
@@ -2,18 +2,18 @@
 {-# LANGUAGE FlexibleContexts, StandaloneDeriving #-}
 module Language.Haskell.Tools.AST.Instances.Eq where
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Modules
+import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Representation.Patterns (UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.TH
 import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Kinds
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
 
 -- Annotations
 instance (Eq (e dom stage)) => Eq (Ann e dom stage) where
@@ -36,6 +36,7 @@
 deriving instance Eq (UFilePragma dom stage)
 deriving instance Eq (UImportDecl dom stage)
 deriving instance Eq (UImportSpec dom stage)
+deriving instance Eq (UImportModifier dom stage)
 deriving instance Eq (UImportQualified dom stage)
 deriving instance Eq (UImportSource dom stage)
 deriving instance Eq (UImportSafe dom stage)
diff --git a/Language/Haskell/Tools/AST/Instances/Generic.hs b/Language/Haskell/Tools/AST/Instances/Generic.hs
--- a/Language/Haskell/Tools/AST/Instances/Generic.hs
+++ b/Language/Haskell/Tools/AST/Instances/Generic.hs
@@ -2,134 +2,135 @@
 {-# LANGUAGE FlexibleContexts, StandaloneDeriving, DeriveGeneric #-}
 module Language.Haskell.Tools.AST.Instances.Generic where
 
-import GHC.Generics
+import GHC.Generics (Generic(..))
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Modules
+import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Representation.Patterns (UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.TH
 import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Kinds
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
 
 -- Annotations
-deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (Ann e dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnMaybeG e dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnListG e dom stage)
+deriving instance Domain dom => Generic (Ann e dom stage)
+deriving instance Domain dom => Generic (AnnMaybeG e dom stage)
+deriving instance Domain dom => Generic (AnnListG e dom stage)
 
 -- Modules
-deriving instance (Domain dom, SourceInfo stage) => Generic (UModule dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UModuleHead dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UExportSpecs dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UExportSpec dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UIESpec dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (USubSpec dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UModulePragma dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFilePragma dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSpec dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportQualified dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSource dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSafe dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeNamespace dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UImportRenaming dom stage)
+deriving instance Domain dom => Generic (UModule dom stage)
+deriving instance Domain dom => Generic (UModuleHead dom stage)
+deriving instance Domain dom => Generic (UExportSpecs dom stage)
+deriving instance Domain dom => Generic (UExportSpec dom stage)
+deriving instance Domain dom => Generic (UIESpec dom stage)
+deriving instance Domain dom => Generic (USubSpec dom stage)
+deriving instance Domain dom => Generic (UModulePragma dom stage)
+deriving instance Domain dom => Generic (UFilePragma dom stage)
+deriving instance Domain dom => Generic (UImportDecl dom stage)
+deriving instance Domain dom => Generic (UImportSpec dom stage)
+deriving instance Domain dom => Generic (UImportModifier dom stage)
+deriving instance Domain dom => Generic (UImportQualified dom stage)
+deriving instance Domain dom => Generic (UImportSource dom stage)
+deriving instance Domain dom => Generic (UImportSafe dom stage)
+deriving instance Domain dom => Generic (UTypeNamespace dom stage)
+deriving instance Domain dom => Generic (UImportRenaming dom stage)
 
 -- Declarations
-deriving instance (Domain dom, SourceInfo stage) => Generic (UDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UClassBody dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UClassElement dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UDeclHead dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UInstBody dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UInstBodyDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UGadtConDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UGadtConType dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldWildcard dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFunDeps dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFunDep dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UConDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldDecl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UDeriving dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UInstanceRule dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UInstanceHead dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeEqn dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UKindConstraint dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTyVar dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UType dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UKind dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UContext dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UAssertion dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UExpr dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UStmt' expr dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UCompStmt dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UValueBind dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPattern dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternField dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (USplice dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (QQString dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UMatch dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UAlt' expr dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (URhs dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UGuardedRhs dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldUpdate dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UBracket dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTopLevelPragma dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (URule dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UAnnotationSubject dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UMinimalFormula dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UExprPragma dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (USourceRange dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (Number dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UQuasiQuote dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (URhsGuard dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (ULocalBind dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (ULocalBinds dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UFixitySignature dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeSignature dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UListCompBody dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTupSecElem dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeFamily dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeFamilySpec dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UInjectivityAnn dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UCaseRhs' expr dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UGuardedCaseRhs' expr dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternSynonym dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynRhs dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynLhs dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynWhere dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternTypeSignature dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (URole dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UCmd dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (ULanguageExtension dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UMatchLhs dom stage)
+deriving instance Domain dom => Generic (UDecl dom stage)
+deriving instance Domain dom => Generic (UClassBody dom stage)
+deriving instance Domain dom => Generic (UClassElement dom stage)
+deriving instance Domain dom => Generic (UDeclHead dom stage)
+deriving instance Domain dom => Generic (UInstBody dom stage)
+deriving instance Domain dom => Generic (UInstBodyDecl dom stage)
+deriving instance Domain dom => Generic (UGadtConDecl dom stage)
+deriving instance Domain dom => Generic (UGadtConType dom stage)
+deriving instance Domain dom => Generic (UFieldWildcard dom stage)
+deriving instance Domain dom => Generic (UFunDeps dom stage)
+deriving instance Domain dom => Generic (UFunDep dom stage)
+deriving instance Domain dom => Generic (UConDecl dom stage)
+deriving instance Domain dom => Generic (UFieldDecl dom stage)
+deriving instance Domain dom => Generic (UDeriving dom stage)
+deriving instance Domain dom => Generic (UInstanceRule dom stage)
+deriving instance Domain dom => Generic (UInstanceHead dom stage)
+deriving instance Domain dom => Generic (UTypeEqn dom stage)
+deriving instance Domain dom => Generic (UKindConstraint dom stage)
+deriving instance Domain dom => Generic (UTyVar dom stage)
+deriving instance Domain dom => Generic (UType dom stage)
+deriving instance Domain dom => Generic (UKind dom stage)
+deriving instance Domain dom => Generic (UContext dom stage)
+deriving instance Domain dom => Generic (UAssertion dom stage)
+deriving instance Domain dom => Generic (UExpr dom stage)
+deriving instance Domain dom => Generic (UStmt' expr dom stage)
+deriving instance Domain dom => Generic (UCompStmt dom stage)
+deriving instance Domain dom => Generic (UValueBind dom stage)
+deriving instance Domain dom => Generic (UPattern dom stage)
+deriving instance Domain dom => Generic (UPatternField dom stage)
+deriving instance Domain dom => Generic (USplice dom stage)
+deriving instance Domain dom => Generic (QQString dom stage)
+deriving instance Domain dom => Generic (UMatch dom stage)
+deriving instance Domain dom => Generic (UAlt' expr dom stage)
+deriving instance Domain dom => Generic (URhs dom stage)
+deriving instance Domain dom => Generic (UGuardedRhs dom stage)
+deriving instance Domain dom => Generic (UFieldUpdate dom stage)
+deriving instance Domain dom => Generic (UBracket dom stage)
+deriving instance Domain dom => Generic (UTopLevelPragma dom stage)
+deriving instance Domain dom => Generic (URule dom stage)
+deriving instance Domain dom => Generic (UAnnotationSubject dom stage)
+deriving instance Domain dom => Generic (UMinimalFormula dom stage)
+deriving instance Domain dom => Generic (UExprPragma dom stage)
+deriving instance Domain dom => Generic (USourceRange dom stage)
+deriving instance Domain dom => Generic (Number dom stage)
+deriving instance Domain dom => Generic (UQuasiQuote dom stage)
+deriving instance Domain dom => Generic (URhsGuard dom stage)
+deriving instance Domain dom => Generic (ULocalBind dom stage)
+deriving instance Domain dom => Generic (ULocalBinds dom stage)
+deriving instance Domain dom => Generic (UFixitySignature dom stage)
+deriving instance Domain dom => Generic (UTypeSignature dom stage)
+deriving instance Domain dom => Generic (UListCompBody dom stage)
+deriving instance Domain dom => Generic (UTupSecElem dom stage)
+deriving instance Domain dom => Generic (UTypeFamily dom stage)
+deriving instance Domain dom => Generic (UTypeFamilySpec dom stage)
+deriving instance Domain dom => Generic (UInjectivityAnn dom stage)
+deriving instance Domain dom => Generic (UCaseRhs' expr dom stage)
+deriving instance Domain dom => Generic (UGuardedCaseRhs' expr dom stage)
+deriving instance Domain dom => Generic (UPatternSynonym dom stage)
+deriving instance Domain dom => Generic (UPatSynRhs dom stage)
+deriving instance Domain dom => Generic (UPatSynLhs dom stage)
+deriving instance Domain dom => Generic (UPatSynWhere dom stage)
+deriving instance Domain dom => Generic (UPatternTypeSignature dom stage)
+deriving instance Domain dom => Generic (URole dom stage)
+deriving instance Domain dom => Generic (UCmd dom stage)
+deriving instance Domain dom => Generic (ULanguageExtension dom stage)
+deriving instance Domain dom => Generic (UMatchLhs dom stage)
 
 
--- ULiteral
-deriving instance (Domain dom, SourceInfo stage) => Generic (ULiteral dom stage)
-deriving instance (Domain dom, SourceInfo stage, Generic (k dom stage)) => Generic (UPromoted k dom stage)
+-- Literal
+deriving instance Domain dom => Generic (ULiteral dom stage)
+deriving instance Domain dom => Generic (UPromoted k dom stage)
 
 -- Base
-deriving instance (Domain dom, SourceInfo stage) => Generic (UOperator dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UName dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UQualifiedName dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UModuleName dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UNamePart dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UStringNode dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UDataOrNewtypeKeyword dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UDoKind dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (TypeKeyword dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UOverlapPragma dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UCallConv dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UArrowAppl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (USafety dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UConlikeAnnot dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (Assoc dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (Precedence dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (LineNumber dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (UPhaseControl dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (PhaseNumber dom stage)
-deriving instance (Domain dom, SourceInfo stage) => Generic (PhaseInvert dom stage)
+deriving instance Domain dom => Generic (UOperator dom stage)
+deriving instance Domain dom => Generic (UName dom stage)
+deriving instance Domain dom => Generic (UQualifiedName dom stage)
+deriving instance Domain dom => Generic (UModuleName dom stage)
+deriving instance Domain dom => Generic (UNamePart dom stage)
+deriving instance Domain dom => Generic (UStringNode dom stage)
+deriving instance Domain dom => Generic (UDataOrNewtypeKeyword dom stage)
+deriving instance Domain dom => Generic (UDoKind dom stage)
+deriving instance Domain dom => Generic (TypeKeyword dom stage)
+deriving instance Domain dom => Generic (UOverlapPragma dom stage)
+deriving instance Domain dom => Generic (UCallConv dom stage)
+deriving instance Domain dom => Generic (UArrowAppl dom stage)
+deriving instance Domain dom => Generic (USafety dom stage)
+deriving instance Domain dom => Generic (UConlikeAnnot dom stage)
+deriving instance Domain dom => Generic (Assoc dom stage)
+deriving instance Domain dom => Generic (Precedence dom stage)
+deriving instance Domain dom => Generic (LineNumber dom stage)
+deriving instance Domain dom => Generic (UPhaseControl dom stage)
+deriving instance Domain dom => Generic (PhaseNumber dom stage)
+deriving instance Domain dom => Generic (PhaseInvert dom stage)
diff --git a/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs b/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs
--- a/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs
+++ b/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs
@@ -3,21 +3,21 @@
            #-}
 module Language.Haskell.Tools.AST.Instances.SemanticTraversal where
 
-import Language.Haskell.Tools.AST.TH.SemanticTraversal
 import Control.Applicative
+import Language.Haskell.Tools.AST.TH.SemanticTraversal
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Types
 import Language.Haskell.Tools.AST.Representation.Kinds
 import Language.Haskell.Tools.AST.Representation.Literals
+import Language.Haskell.Tools.AST.Representation.Modules
 import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.Stmts
+import Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Representation.Types
 
 
 -- Modules
@@ -31,6 +31,7 @@
 deriveSemanticTraversal ''UFilePragma
 deriveSemanticTraversal ''UImportDecl
 deriveSemanticTraversal ''UImportSpec
+deriveSemanticTraversal ''UImportModifier
 deriveSemanticTraversal ''UImportQualified
 deriveSemanticTraversal ''UImportSource
 deriveSemanticTraversal ''UImportSafe
diff --git a/Language/Haskell/Tools/AST/Instances/Show.hs b/Language/Haskell/Tools/AST/Instances/Show.hs
--- a/Language/Haskell/Tools/AST/Instances/Show.hs
+++ b/Language/Haskell/Tools/AST/Instances/Show.hs
@@ -2,18 +2,18 @@
 {-# LANGUAGE FlexibleContexts, StandaloneDeriving #-}
 module Language.Haskell.Tools.AST.Instances.Show where
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Modules
+import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Representation.Patterns (UPatternField(..), UPattern(..))
 import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.TH
 import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Kinds
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
 
 -- Annotations
 instance (Show (e dom stage)) => Show (Ann e dom stage) where
@@ -36,6 +36,7 @@
 deriving instance Show (UFilePragma dom stage)
 deriving instance Show (UImportDecl dom stage)
 deriving instance Show (UImportSpec dom stage)
+deriving instance Show (UImportModifier dom stage)
 deriving instance Show (UImportQualified dom stage)
 deriving instance Show (UImportSource dom stage)
 deriving instance Show (UImportSafe dom stage)
diff --git a/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs b/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs
--- a/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs
+++ b/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs
@@ -3,21 +3,21 @@
            #-}
 module Language.Haskell.Tools.AST.Instances.SourceInfoTraversal where
 
-import Language.Haskell.Tools.AST.TH.SourceInfoTraversal
 import Control.Applicative
+import Language.Haskell.Tools.AST.TH.SourceInfoTraversal
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Types
 import Language.Haskell.Tools.AST.Representation.Kinds
 import Language.Haskell.Tools.AST.Representation.Literals
+import Language.Haskell.Tools.AST.Representation.Modules
 import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.Stmts
+import Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Representation.Types
 
 
 -- Modules
@@ -31,6 +31,7 @@
 deriveSourceInfoTraversal ''UFilePragma
 deriveSourceInfoTraversal ''UImportDecl
 deriveSourceInfoTraversal ''UImportSpec
+deriveSourceInfoTraversal ''UImportModifier
 deriveSourceInfoTraversal ''UImportQualified
 deriveSourceInfoTraversal ''UImportSource
 deriveSourceInfoTraversal ''UImportSafe
diff --git a/Language/Haskell/Tools/AST/MakeASTReferences.hs b/Language/Haskell/Tools/AST/MakeASTReferences.hs
--- a/Language/Haskell/Tools/AST/MakeASTReferences.hs
+++ b/Language/Haskell/Tools/AST/MakeASTReferences.hs
@@ -3,12 +3,9 @@
 -- function @makeReferences@.
 module Language.Haskell.Tools.AST.MakeASTReferences where
 
-import Control.Monad
 import Control.Reference ((&))
-import Language.Haskell.Tools.AST.Ann (Ann, element)
 import Language.Haskell.TH
-
-import Debug.Trace
+import Language.Haskell.Tools.AST.Ann (Ann, element)
 
 -- | Change the generated references to have the context of an annotated element.
 -- Modifies the types according to the changes. This trasformation makes all
diff --git a/Language/Haskell/Tools/AST/References.hs b/Language/Haskell/Tools/AST/References.hs
--- a/Language/Haskell/Tools/AST/References.hs
+++ b/Language/Haskell/Tools/AST/References.hs
@@ -5,18 +5,18 @@
 import Control.Reference hiding (element)
 import Language.Haskell.Tools.AST.MakeASTReferences
 
-import Language.Haskell.Tools.AST.Representation.Modules
-import Language.Haskell.Tools.AST.Representation.TH
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.Representation.Binds
+import Language.Haskell.Tools.AST.Representation.Decls
 import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Stmts
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Types
 import Language.Haskell.Tools.AST.Representation.Kinds
 import Language.Haskell.Tools.AST.Representation.Literals
+import Language.Haskell.Tools.AST.Representation.Modules
 import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Representation.Patterns
+import Language.Haskell.Tools.AST.Representation.Stmts
+import Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Representation.Types
 
 -- * Modules
 $(toASTReferences (makeReferences ''UModule))
diff --git a/Language/Haskell/Tools/AST/Representation/Binds.hs b/Language/Haskell/Tools/AST/Representation/Binds.hs
--- a/Language/Haskell/Tools/AST/Representation/Binds.hs
+++ b/Language/Haskell/Tools/AST/Representation/Binds.hs
@@ -1,13 +1,11 @@
 -- | Representation of Haskell AST value and function bindings (both local and top-level)
 module Language.Haskell.Tools.AST.Representation.Binds where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Literals
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
+import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Types (UType(..))
 
 -- | Value binding for top-level and local bindings
 data UValueBind dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/Decls.hs b/Language/Haskell/Tools/AST/Representation/Decls.hs
--- a/Language/Haskell/Tools/AST/Representation/Decls.hs
+++ b/Language/Haskell/Tools/AST/Representation/Decls.hs
@@ -2,19 +2,18 @@
 -- The definition of value bindings are in the Binds module.
 module Language.Haskell.Tools.AST.Representation.Decls where
 
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
 import Language.Haskell.Tools.AST.Representation.Binds
-import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Kinds
-import Language.Haskell.Tools.AST.Representation.Exprs
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
+import Language.Haskell.Tools.AST.Representation.Kinds (UKindConstraint(..))
 import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Ann
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (USplice(..))
+import Language.Haskell.Tools.AST.Representation.Types (UContext(..), UType(..), UTyVar(..))
 
 -- * Declarations
 
--- | Haskell declaration
+-- | Haskell declarationw
 data UDecl dom stage
   = UTypeDecl             { _declHead :: Ann UDeclHead dom stage
                           , _declType :: Ann UType dom stage
@@ -131,7 +130,7 @@
   | UClsMinimal { _pragmaFormula :: Ann UMinimalFormula dom stage
                 } -- ^ Minimal pragma: @ {-# MINIMAL (==) | (/=) #-} @
   -- not supported yet (GHC 8.0.1)
-  -- | UClsPatSig  { _cePatSig :: Ann UPatternTypeSignature dom stage
+-- | UClsPatSig  { _cePatSig :: Ann UPatternTypeSignature dom stage
   --               } -- ^ Pattern signature in a class declaration (by using @PatternSynonyms@)
 
 -- * Type class instances
@@ -183,7 +182,7 @@
   | USpecializeInstance   { _specializeInstanceType :: Ann UType dom stage
                           } -- ^ Specialize instance pragma (no phase selection is allowed)
   -- not supported yet
-  -- | UInstBodyPatSyn       { _instBodyPatSyn :: Ann UPatternSynonym dom stage
+-- | UInstBodyPatSyn       { _instBodyPatSyn :: Ann UPatternSynonym dom stage
   --                         } -- ^ A pattern synonym in a class instance
 
 -- | Overlap pragmas. Can be applied to class declarations and class instance declarations.    
diff --git a/Language/Haskell/Tools/AST/Representation/Exprs.hs b/Language/Haskell/Tools/AST/Representation/Exprs.hs
--- a/Language/Haskell/Tools/AST/Representation/Exprs.hs
+++ b/Language/Haskell/Tools/AST/Representation/Exprs.hs
@@ -1,14 +1,14 @@
 -- | Representation of Haskell expressions
 module Language.Haskell.Tools.AST.Representation.Exprs where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Stmts
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind, ULocalBinds, URhsGuard)
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Names (UStringNode(..), UName(..), UOperator(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Stmts
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UBracket(..), UQuasiQuote(..), USplice(..))
+import Language.Haskell.Tools.AST.Representation.Types (UType(..))
 
 -- | Haskell expressions
 data UExpr dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/Kinds.hs b/Language/Haskell/Tools/AST/Representation/Kinds.hs
--- a/Language/Haskell/Tools/AST/Representation/Kinds.hs
+++ b/Language/Haskell/Tools/AST/Representation/Kinds.hs
@@ -1,9 +1,8 @@
 -- | Representation of Haskell Kinds
 module Language.Haskell.Tools.AST.Representation.Kinds where
 
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
+import Language.Haskell.Tools.AST.Representation.Names (UName(..))
 
 -- | Kind constraint (@ :: * -> * @)
 data UKindConstraint dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/Literals.hs b/Language/Haskell/Tools/AST/Representation/Literals.hs
--- a/Language/Haskell/Tools/AST/Representation/Literals.hs
+++ b/Language/Haskell/Tools/AST/Representation/Literals.hs
@@ -1,9 +1,6 @@
 -- | Representation of Haskell literals
 module Language.Haskell.Tools.AST.Representation.Literals where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
-
 -- | Haskell literals
 data ULiteral dom stage
   = UCharLit { _charLitValue :: Char 
diff --git a/Language/Haskell/Tools/AST/Representation/Modules.hs b/Language/Haskell/Tools/AST/Representation/Modules.hs
--- a/Language/Haskell/Tools/AST/Representation/Modules.hs
+++ b/Language/Haskell/Tools/AST/Representation/Modules.hs
@@ -1,11 +1,9 @@
 -- | Representation of Haskell modules, imports and exports. Also contains file-level pragmas.
 module Language.Haskell.Tools.AST.Representation.Modules where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Binds
-import Language.Haskell.Tools.AST.Representation.Decls
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Representation.Decls (UDecl(..))
+import Language.Haskell.Tools.AST.Representation.Names (UStringNode(..), UName(..))
 
 -- | The representation of a haskell module, that is a separate compilation unit.
 -- It may or may not have a header.
@@ -36,9 +34,14 @@
   
 -- | Marks a name to be imported or exported with related names (subspecifier)
 data UIESpec dom stage
-  = UIESpec { _ieName :: Ann UName dom stage
+  = UIESpec { _ieModifier :: AnnMaybeG UImportModifier dom stage
+            , _ieName :: Ann UName dom stage
             , _ieSubspec :: AnnMaybeG USubSpec dom stage
             }
+
+-- | Specifies the imported element
+data UImportModifier dom stage
+  = UImportPattern -- ^ @pattern@: modifier for importing pattern synonyms
   
 -- | Marks how related names will be imported or exported with a given name
 data USubSpec dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/Names.hs b/Language/Haskell/Tools/AST/Representation/Names.hs
--- a/Language/Haskell/Tools/AST/Representation/Names.hs
+++ b/Language/Haskell/Tools/AST/Representation/Names.hs
@@ -7,7 +7,7 @@
 -- | Simple AST elements of Haskell
 module Language.Haskell.Tools.AST.Representation.Names where
   
-import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
 
 data UOperator dom stage
   = UBacktickOp { _operatorName :: Ann UQualifiedName dom stage 
diff --git a/Language/Haskell/Tools/AST/Representation/Patterns.hs b/Language/Haskell/Tools/AST/Representation/Patterns.hs
--- a/Language/Haskell/Tools/AST/Representation/Patterns.hs
+++ b/Language/Haskell/Tools/AST/Representation/Patterns.hs
@@ -1,12 +1,12 @@
 -- | Representation of Haskell patterns
 module Language.Haskell.Tools.AST.Representation.Patterns where
           
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names  
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Types
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UFieldWildcard)
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UFieldWildcard)  
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
+import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote(..), USplice(..))
+import Language.Haskell.Tools.AST.Representation.Types (UType(..))
 
         
 -- | Representation of patterns for pattern bindings
diff --git a/Language/Haskell/Tools/AST/Representation/Stmts.hs b/Language/Haskell/Tools/AST/Representation/Stmts.hs
--- a/Language/Haskell/Tools/AST/Representation/Stmts.hs
+++ b/Language/Haskell/Tools/AST/Representation/Stmts.hs
@@ -1,11 +1,10 @@
 -- | Representation of Haskell statements (both do-notation and comprehensions)
 module Language.Haskell.Tools.AST.Representation.Stmts where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Patterns
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UCmd)
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind)
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UCmd)
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
 
 -- | Normal monadic statements
 data UStmt' expr dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/TH.hs b/Language/Haskell/Tools/AST/Representation/TH.hs
--- a/Language/Haskell/Tools/AST/Representation/TH.hs
+++ b/Language/Haskell/Tools/AST/Representation/TH.hs
@@ -1,13 +1,12 @@
 -- | Representation of Template Haskell AST elements
 module Language.Haskell.Tools.AST.Representation.TH where
               
-import Language.Haskell.Tools.AST.Representation.Decls
-import Language.Haskell.Tools.AST.Representation.Binds
-import Language.Haskell.Tools.AST.Representation.Exprs
-import Language.Haskell.Tools.AST.Representation.Patterns
-import Language.Haskell.Tools.AST.Representation.Types
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Ann
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
+import Language.Haskell.Tools.AST.Representation.Decls (UDecl(..))
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
+import Language.Haskell.Tools.AST.Representation.Names (UName(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Types (UType(..))
               
 -- | A template haskell splice          
 data USplice dom stage
diff --git a/Language/Haskell/Tools/AST/Representation/Types.hs b/Language/Haskell/Tools/AST/Representation/Types.hs
--- a/Language/Haskell/Tools/AST/Representation/Types.hs
+++ b/Language/Haskell/Tools/AST/Representation/Types.hs
@@ -1,11 +1,10 @@
 -- | Representation of Haskell types
 module Language.Haskell.Tools.AST.Representation.Types where
 
-import Language.Haskell.Tools.AST.Ann
-import Language.Haskell.Tools.AST.Representation.Literals
-import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Kinds
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH
+import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote(..), USplice(..))
 
 -- | Type variable declaration
 data UTyVar dom stage
diff --git a/Language/Haskell/Tools/AST/SemaInfoClasses.hs b/Language/Haskell/Tools/AST/SemaInfoClasses.hs
--- a/Language/Haskell/Tools/AST/SemaInfoClasses.hs
+++ b/Language/Haskell/Tools/AST/SemaInfoClasses.hs
@@ -7,16 +7,15 @@
 module Language.Haskell.Tools.AST.SemaInfoClasses where
 
 import GHC
-import Id as GHC
-import BasicTypes as GHC
+import Id as GHC (Id(..), idName)
 
-import Control.Reference
+import Control.Reference ((^?), (^.), (&))
 
 import Language.Haskell.Tools.AST.Ann as AST
+import Language.Haskell.Tools.AST.Representation.Exprs as AST (UFieldWildcard(..), UExpr(..))
+import Language.Haskell.Tools.AST.Representation.Modules as AST (UImportDecl(..), UModule(..))
+import Language.Haskell.Tools.AST.Representation.Names as AST (UQualifiedName(..))
 import Language.Haskell.Tools.AST.SemaInfoTypes as AST
-import Language.Haskell.Tools.AST.Representation.Modules as AST
-import Language.Haskell.Tools.AST.Representation.Names as AST
-import Language.Haskell.Tools.AST.Representation.Exprs as AST
 
 -- * Information about names
 
@@ -120,21 +119,29 @@
   semanticsModule :: si -> GHC.Module
   isBootModule :: si -> Bool
   semanticsImplicitImports :: si -> [GHC.Name]
+  semanticsPrelOrphanInsts :: si -> [ClsInst]
+  semanticsPrelFamInsts :: si -> [FamInst]
 
 instance HasModuleInfo' (AST.ModuleInfo GHC.Name) where
   semanticsModule = (^. defModuleName)
   isBootModule = (^. defIsBootModule)
   semanticsImplicitImports = (^. implicitNames)
+  semanticsPrelOrphanInsts = (^. prelOrphanInsts)
+  semanticsPrelFamInsts = (^. prelFamInsts)
 
 instance HasModuleInfo' (AST.ModuleInfo GHC.Id) where
   semanticsModule = (^. defModuleName)
   isBootModule = (^. defIsBootModule)
   semanticsImplicitImports = map idName . (^. implicitNames)
+  semanticsPrelOrphanInsts = (^. prelOrphanInsts)
+  semanticsPrelFamInsts = (^. prelFamInsts)
 
 instance HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) where
   semanticsModule = semanticsModule . (^. annotation&semanticInfo) 
   isBootModule = isBootModule . (^. annotation&semanticInfo) 
   semanticsImplicitImports = semanticsImplicitImports . (^. annotation&semanticInfo) 
+  semanticsPrelOrphanInsts = semanticsPrelOrphanInsts . (^. annotation&semanticInfo) 
+  semanticsPrelFamInsts = semanticsPrelFamInsts . (^. annotation&semanticInfo) 
 
 -- * Information about imports
 
@@ -144,21 +151,29 @@
   semanticsImportedModule :: si -> GHC.Module
   semanticsAvailable :: si -> [GHC.Name]
   semanticsImported :: si -> [GHC.Name]
+  semanticsOrphanInsts :: si -> [ClsInst]
+  semanticsFamInsts :: si -> [FamInst]
 
 instance HasImportInfo' (AST.ImportInfo GHC.Name) where
   semanticsImportedModule = (^. importedModule)
   semanticsAvailable = (^. availableNames)
   semanticsImported = (^. importedNames)
+  semanticsOrphanInsts = (^. importedOrphanInsts)
+  semanticsFamInsts = (^. importedFamInsts)
 
 instance HasImportInfo' (AST.ImportInfo GHC.Id) where
   semanticsImportedModule = (^. importedModule)
   semanticsAvailable = map idName . (^. availableNames)
   semanticsImported = map idName . (^. importedNames)
+  semanticsOrphanInsts = (^. importedOrphanInsts)
+  semanticsFamInsts = (^. importedFamInsts)
 
 instance HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) where
   semanticsImportedModule = semanticsImportedModule . (^. annotation&semanticInfo) 
   semanticsAvailable = semanticsAvailable . (^. annotation&semanticInfo) 
   semanticsImported = semanticsImported . (^. annotation&semanticInfo) 
+  semanticsOrphanInsts = semanticsOrphanInsts . (^. annotation&semanticInfo) 
+  semanticsFamInsts = semanticsFamInsts . (^. annotation&semanticInfo) 
 
 -- * Information about implicitely bounded fields
 
diff --git a/Language/Haskell/Tools/AST/SemaInfoTypes.hs b/Language/Haskell/Tools/AST/SemaInfoTypes.hs
--- a/Language/Haskell/Tools/AST/SemaInfoTypes.hs
+++ b/Language/Haskell/Tools/AST/SemaInfoTypes.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE DeriveDataTypeable
+           , StandaloneDeriving 
            , TemplateHaskell 
            , UndecidableInstances
            , FlexibleContexts
@@ -12,23 +13,24 @@
   , exprScopedLocals, nameScopedLocals, nameIsDefined, nameInfo, ambiguousName, nameLocation
   , implicitName, cnameScopedLocals, cnameIsDefined, cnameInfo, cnameFixity
   , defModuleName, defIsBootModule, implicitNames, importedModule, availableNames, importedNames
-  , implicitFieldBindings
+  , implicitFieldBindings, importedOrphanInsts, importedFamInsts, prelOrphanInsts, prelFamInsts
     -- creator functions
   , mkNoSemanticInfo, mkScopeInfo, mkNameInfo, mkAmbiguousNameInfo, mkImplicitNameInfo, mkCNameInfo
   , mkModuleInfo, mkImportInfo, mkImplicitFieldInfo
   ) where
 
-import Name as GHC
 import BasicTypes as GHC
+import FamInstEnv as GHC
 import Id as GHC
+import InstEnv as GHC
 import Module as GHC
-import SrcLoc as GHC
-import RdrName as GHC
+import Name as GHC
 import Outputable as GHC
+import RdrName as GHC
+import SrcLoc as GHC
 
-import Data.Maybe
-import Data.List
 import Data.Data
+import Data.List
 
 import Control.Reference
 
@@ -97,22 +99,29 @@
 data ModuleInfo n = ModuleInfo { _defModuleName :: GHC.Module 
                                , _defIsBootModule :: Bool -- ^ True if this module is created from a hs-boot file
                                , _implicitNames :: [n] -- ^ Implicitely imported names
+                               , _prelOrphanInsts :: [ClsInst] -- ^ Class instances implicitely passed from Prelude.
+                               , _prelFamInsts :: [FamInst] -- ^ Family instances implicitely passed from Prelude.
                                } 
-  deriving (Eq, Data)
+  deriving Data
 
 -- | Creates semantic information for the module element
-mkModuleInfo :: GHC.Module -> Bool -> [n] -> ModuleInfo n
+mkModuleInfo :: GHC.Module -> Bool -> [n] -> [ClsInst] -> [FamInst] -> ModuleInfo n
 mkModuleInfo = ModuleInfo
 
 -- | Info corresponding to an import declaration
 data ImportInfo n = ImportInfo { _importedModule :: GHC.Module -- ^ The name and package of the imported module
                                , _availableNames :: [n] -- ^ Names available from the imported module
                                , _importedNames :: [n] -- ^ Names actually imported from the module.
-                               } 
-  deriving (Eq, Data)
+                               , _importedOrphanInsts :: [ClsInst] -- ^ Class instances implicitely passed.
+                               , _importedFamInsts :: [FamInst] -- ^ Family instances implicitely passed.
+                               }
+  deriving Data
 
+deriving instance Data FamInst
+deriving instance Data FamFlavor
+
 -- | Creates semantic information for an import declaration
-mkImportInfo :: GHC.Module -> [n] -> [n] -> ImportInfo n
+mkImportInfo :: GHC.Module -> [n] -> [n] -> [ClsInst] -> [FamInst] -> ImportInfo n
 mkImportInfo = ImportInfo
 
 -- | Info corresponding to an record-wildcard
@@ -136,10 +145,14 @@
   show (CNameInfo locals defined nameInfo fixity) = "(CNameInfo " ++ showSDocUnsafe (ppr locals) ++ " " ++ show defined ++ " " ++ showSDocUnsafe (ppr nameInfo) ++ showSDocUnsafe (ppr fixity) ++ ")"
 
 instance Outputable n => Show (ModuleInfo n) where
-  show (ModuleInfo mod isboot imp) = "(ModuleInfo " ++ showSDocUnsafe (ppr mod) ++ " " ++ show isboot ++ " " ++ showSDocUnsafe (ppr imp) ++ ")"
+  show (ModuleInfo mod isboot imp clsInsts famInsts) 
+    = "(ModuleInfo " ++ showSDocUnsafe (ppr mod) ++ " " ++ show isboot ++ " " ++ showSDocUnsafe (ppr imp) ++ " " 
+          ++ showSDocUnsafe (ppr clsInsts) ++ " " ++ showSDocUnsafe (ppr famInsts) ++ ")"
 
 instance Outputable n => Show (ImportInfo n) where
-  show (ImportInfo mod avail imported) = "(ImportInfo " ++ showSDocUnsafe (ppr mod) ++ " " ++ showSDocUnsafe (ppr avail) ++ " " ++ showSDocUnsafe (ppr imported) ++ ")"
+  show (ImportInfo mod avail imported clsInsts famInsts) 
+    = "(ImportInfo " ++ showSDocUnsafe (ppr mod) ++ " " ++ showSDocUnsafe (ppr avail) ++ " " ++ showSDocUnsafe (ppr imported) ++ " " 
+          ++ showSDocUnsafe (ppr clsInsts) ++ " " ++ showSDocUnsafe (ppr famInsts) ++ ")"
 
 instance Show ImplicitFieldInfo where
   show (ImplicitFieldInfo bnds) = "(ImplicitFieldInfo [" ++ concat (intersperse "," (map (\(from,to) -> showSDocUnsafe (ppr from) ++ "->" ++ showSDocUnsafe (ppr to)) bnds)) ++ "])"
@@ -162,7 +175,7 @@
   fmap f = implicitNames .- map f
 
 instance Functor ImportInfo where
-  fmap f (ImportInfo mod avail imps) = ImportInfo mod (map f avail) (map f imps)
+  fmap f (ImportInfo mod avail imps clsInsts famInsts) = ImportInfo mod (map f avail) (map f imps) clsInsts famInsts
 
 instance Foldable NameInfo where
   foldMap f si = maybe mempty f (si ^? nameInfo)
@@ -175,12 +188,14 @@
 
 instance Traversable NameInfo where
   traverse f (NameInfo locals defined nameInfo) = NameInfo locals defined <$> f nameInfo
-  traverse f (AmbiguousNameInfo locals defined nameInfo span) = pure $ AmbiguousNameInfo locals defined nameInfo span
-  traverse f (ImplicitNameInfo locals defined nameInfo span) = pure $ ImplicitNameInfo locals defined nameInfo span
+  traverse _ (AmbiguousNameInfo locals defined nameInfo span) = pure $ AmbiguousNameInfo locals defined nameInfo span
+  traverse _ (ImplicitNameInfo locals defined nameInfo span) = pure $ ImplicitNameInfo locals defined nameInfo span
 
 instance Traversable ModuleInfo where
-  traverse f (ModuleInfo mod isboot imp) = ModuleInfo mod isboot <$> traverse f imp 
+  traverse f (ModuleInfo mod isboot imp clsInsts famInsts) 
+    = ModuleInfo mod isboot <$> traverse f imp <*> pure clsInsts <*> pure famInsts
 
 instance Traversable ImportInfo where
-  traverse f (ImportInfo mod avail imps) = ImportInfo mod <$> traverse f avail <*> traverse f imps
+  traverse f (ImportInfo mod avail imps clsInsts famInsts) 
+    = ImportInfo mod <$> traverse f avail <*> traverse f imps <*> pure clsInsts <*> pure famInsts
 
diff --git a/Language/Haskell/Tools/AST/TH/SemanticTraversal.hs b/Language/Haskell/Tools/AST/TH/SemanticTraversal.hs
--- a/Language/Haskell/Tools/AST/TH/SemanticTraversal.hs
+++ b/Language/Haskell/Tools/AST/TH/SemanticTraversal.hs
@@ -1,13 +1,12 @@
 {-# LANGUAGE LambdaCase
-           , CPP 
            , TemplateHaskell
            #-}
 -- | Generating instances for traversal on semantic information
 module Language.Haskell.Tools.AST.TH.SemanticTraversal where
 
 import Control.Monad
-import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Ppr
+import Language.Haskell.TH.Syntax
 import Language.Haskell.Tools.AST.Ann
 
 -- | Generate the instances for semantic information
@@ -32,6 +31,7 @@
         createClause (RecC conName conArgs) = createClause' conName (map (\(_,_,t) -> t) conArgs)
         createClause (NormalC conName conArgs) = createClause' conName (map snd conArgs)
         createClause (InfixC conArg1 conName conArg2) = createClause' conName [snd conArg1, snd conArg2]
+        createClause _ = error "createClause: forall and GADT constructors are not supported"
         
         createClause' :: Name -> [Type] -> Q Clause
         createClause' conName args
diff --git a/Language/Haskell/Tools/AST/TH/SourceInfoTraversal.hs b/Language/Haskell/Tools/AST/TH/SourceInfoTraversal.hs
--- a/Language/Haskell/Tools/AST/TH/SourceInfoTraversal.hs
+++ b/Language/Haskell/Tools/AST/TH/SourceInfoTraversal.hs
@@ -1,13 +1,12 @@
 {-# LANGUAGE LambdaCase
-           , CPP 
            , TemplateHaskell
            #-}
 -- | Generating instances for traversal on semantic information
 module Language.Haskell.Tools.AST.TH.SourceInfoTraversal where
 
 import Control.Monad
-import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Ppr
+import Language.Haskell.TH.Syntax
 import Language.Haskell.Tools.AST.Ann
 
 -- | Generate the instances for semantic information
@@ -34,7 +33,8 @@
         createClause funName updown (RecC conName conArgs) = createClause' funName updown conName (map (\(_,_,t) -> t) conArgs)
         createClause funName updown (NormalC conName conArgs) = createClause' funName updown conName (map snd conArgs)
         createClause funName updown (InfixC conArg1 conName conArg2) = createClause' funName updown conName [snd conArg1, snd conArg2]
-        
+        createClause _ _ _ = error "createClause: forall and GADT constructors are not supported"
+
         createClause' :: Name -> Bool -> Name -> [Type] -> Q Clause
         createClause' funName updown conName args
           = do bindedNames <- replicateM (length args) (newName "p")
@@ -66,7 +66,7 @@
        
         -- | Creates the expression and the predicate for a parameter
         processParam :: Name -> Bool -> Name -> Type -> Exp
-        processParam funName updown arg (AppT (AppT t (VarT dom)) (VarT stage)) | dom == tdom && stage == tstage
+        processParam funName updown arg (AppT (AppT _ (VarT dom)) (VarT stage)) | dom == tdom && stage == tstage
           = AppE (wrapUpdown $ AppE (VarE funName) (VarE trf)) (VarE arg)
           where wrapUpdown | updown    = flip AppE (VarE asc) . flip AppE (VarE desc)
                            | otherwise = id
diff --git a/Language/Haskell/Tools/AST/Utils/GHCInstances.hs b/Language/Haskell/Tools/AST/Utils/GHCInstances.hs
--- a/Language/Haskell/Tools/AST/Utils/GHCInstances.hs
+++ b/Language/Haskell/Tools/AST/Utils/GHCInstances.hs
@@ -11,9 +11,13 @@
 
     gunfold k z c = case constrIndex c of
                         1 -> k (k (k (z mkRealSrcLoc)))
+                        _ -> error "gunfold: has only 1 constructor"
 
     toConstr _ = con_RSL
     dataTypeOf _ = ty_RSL
 
+con_RSL :: Constr
 con_RSL = mkConstr ty_RSL "RSL" [] Prefix
+
+ty_RSL :: DataType
 ty_RSL   = mkDataType "SrcLoc.RealSrcLoc" [con_RSL]
diff --git a/Language/Haskell/Tools/AST/Utils/OrdSrcSpan.hs b/Language/Haskell/Tools/AST/Utils/OrdSrcSpan.hs
--- a/Language/Haskell/Tools/AST/Utils/OrdSrcSpan.hs
+++ b/Language/Haskell/Tools/AST/Utils/OrdSrcSpan.hs
@@ -1,8 +1,8 @@
 -- | A wrapper for SrcSpans that is ordered.
 module Language.Haskell.Tools.AST.Utils.OrdSrcSpan where
 
+import FastString (FastString(..))
 import SrcLoc
-import FastString
 
 -- | Wraps the SrcSpan into an ordered source span
 ordSrcSpan :: SrcSpan -> OrdSrcSpan
diff --git a/haskell-tools-ast.cabal b/haskell-tools-ast.cabal
--- a/haskell-tools-ast.cabal
+++ b/haskell-tools-ast.cabal
@@ -1,5 +1,5 @@
 name:                haskell-tools-ast
-version:             0.4.1.1
+version:             0.4.1.2
 synopsis:            Haskell AST for efficient tooling
 description:         A representation of a Haskell Syntax tree that contain source-related and semantic annotations. These annotations help developer tools to work with the defined program. The source information enables refactoring and program transformation tools to change the source code without losing the original format (layout, comments) of the source. Semantic information helps analyzing the program. The representation is different from the GHC's syntax tree. It contains information from all representations in GHC (different version of syntax trees, lexical and module-level information). The module is split up to put the representation of different language elements into different modules. Additionally, it contains the representation of semantic and source annotations, helper functions and generated instances for the representation of language elements. Because langauge elements may refer each other (there can be a pattern inside an expression in case of a pattern match and an expression inside a pattern if view patterns are enabled), we use hs-boot files to break up dependency cycles.