diff --git a/Language/Haskell/Tools/BackendGHC/AddTypeInfo.hs b/Language/Haskell/Tools/BackendGHC/AddTypeInfo.hs
--- a/Language/Haskell/Tools/BackendGHC/AddTypeInfo.hs
+++ b/Language/Haskell/Tools/BackendGHC/AddTypeInfo.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE LambdaCase, ScopedTypeVariables, TupleSections #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections #-}
 
 module Language.Haskell.Tools.BackendGHC.AddTypeInfo (addTypeInfos) where
 
@@ -16,6 +18,7 @@
 import UniqDFM as GHC (eltsUDFM)
 import UniqSupply as GHC (uniqFromSupply, mkSplitUniqSupply)
 import Var as GHC (Var(..))
+import HsExtension
 
 import Control.Applicative (Applicative(..), (<$>), Alternative(..))
 import Control.Exception (evaluate, throw)
@@ -33,7 +36,7 @@
 import Language.Haskell.Tools.BackendGHC.GHCUtils (getTopLevelId)
 import Language.Haskell.Tools.BackendGHC.Utils (ConvertionProblem(..), forceElements, convProblem)
 
-addTypeInfos :: LHsBinds Id -> Ann AST.UModule (Dom GHC.Name) RangeStage -> Ghc (Ann AST.UModule IdDom RangeStage)
+addTypeInfos :: LHsBinds GhcTc -> Ann AST.UModule (Dom GhcRn) RangeStage -> Ghc (Ann AST.UModule IdDom RangeStage)
 addTypeInfos bnds mod = do
   ut <- liftIO mkUnknownType
   let getType = getType' ut
@@ -56,13 +59,14 @@
                                                  ((_,id):more) -> do put (none ++ more)
                                                                      return $ createCName (AST.semanticsScope ni) (AST.semanticsDefining ni) id
                 _ -> convProblem "addTypeInfos: Cannot access a the semantics of a name.")
-      pure fetchLitType (traverse (lift . getType)) (traverse (lift . getType)) pure
+      pure fetchLitType (lift . trfImportInfoM getType) (lift . trfModuleInfoM getType) pure
         pure) mod) (extractSigIds bnds ++ extractSigBindIds bnds)
   where locMapping = Map.fromList $ map (\(L l id) -> (l, id)) $ extractExprIds bnds
+        getType' :: Type -> Name -> Ghc Id
         getType' ut name = fromMaybe (mkVanillaGlobal name ut) <$> ((<|> Map.lookup name ids) <$> getTopLevelId name)
         ids = Map.fromList $ map (\id -> (getName id, id)) $ extractTypes bnds
 
-        extractTypes :: LHsBinds Id -> [Id]
+        extractTypes :: LHsBinds GhcTc -> [Id]
         extractTypes = concatMap universeBi . bagToList
 
         fetchLitType :: Monad m => PreLiteralInfo -> m LiteralInfo
@@ -75,13 +79,13 @@
         --       because they contain only UnhelpfulSrcSpans
         decompedOverloadedLits :: [(SrcSpan, Type)]
         decompedOverloadedLits = catMaybes $ map decompExprLit exprLits ++ map decompPatLit patLits
-          where exprLits :: [LHsExpr Id]
+          where exprLits :: [LHsExpr GhcTc]
                 exprLits = concatMap universeBi . bagToList $ bnds
 
                 decompExprLit (L loc (HsOverLit lit)) = Just (loc, ol_type lit)
                 decompExprLit x = Nothing
 
-                patLits :: [LPat Id]
+                patLits :: [LPat GhcTc]
                 patLits = concatMap universeBi . bagToList $ bnds
 
                 decompPatLit (L loc (NPat llit _ _ _)) = Just (loc, ol_type . unLoc $ llit)
@@ -100,27 +104,29 @@
                              ifaces = moduleEnvElts pit ++ map hm_iface (eltsUDFM hpt)
                          return $ concatMap (\mi -> map (mi_module mi, ) $ mi_fixities mi) ifaces
 
-extractExprIds :: LHsBinds Id -> [Located Id]
+extractExprIds :: LHsBinds GhcTc -> [Located Id]
         -- expressions like HsRecFld are removed from the typechecked representation, they are replaced by HsVar
-extractExprIds = catMaybes . map (\case L l (HsVar (L _ n)) -> Just (L l n)
+extractExprIds = catMaybes . map (\case L l (HsVar (L _ n) :: HsExpr GhcTc) -> Just (L l n)
                                         L l (HsWrap _ (HsVar (L _ n))) -> Just (L l n)
                                         _ -> Nothing
                                  ) . concatMap universeBi . bagToList
 
-extractSigIds :: LHsBinds Id -> [(SrcSpan,Id)]
+extractSigIds :: LHsBinds GhcTc -> [(SrcSpan,Id)]
 extractSigIds = filter (isGoodSrcSpan . fst)
                   . concat
-                  . map (\case L l bs@(AbsBindsSig {} :: HsBind Id) -> map (l,) $ getImplVars (abs_sig_ev_bind bs)
-                               _                                    -> [] )
+                  . map (\case L l bs@(AbsBinds { abs_sig = True } :: HsBind GhcTc)
+                                 -> map (l,) $ concatMap getImplVars (abs_ev_binds bs)
+                               _ -> [] )
                   . concatMap universeBi . bagToList
   where getImplVars (EvBinds evbnds) = catMaybes $ map getEvVar $ bagToList evbnds
         getImplVars _                = []
         getEvVar (EvBind lhs _ False) = Just lhs
         getEvVar _                    = Nothing
 
-extractSigBindIds :: LHsBinds Id -> [(SrcSpan,Id)]
+extractSigBindIds :: LHsBinds GhcTc -> [(SrcSpan,Id)]
 extractSigBindIds = filter (isGoodSrcSpan . fst)
                       . catMaybes
-                      . map (\case L l (IPBind (Right id) _) -> Just (l,id)
-                                   _                         -> Nothing )
-                      . concatMap universeBi . bagToList
+                      . map (\case L l (IPBind (Right id) _ :: IPBind GhcTc) -> Just (l,id)
+                                   _                                         -> Nothing )
+                      . concatMap universeBi
+                      . bagToList
diff --git a/Language/Haskell/Tools/BackendGHC/Binds.hs b/Language/Haskell/Tools/BackendGHC/Binds.hs
--- a/Language/Haskell/Tools/BackendGHC/Binds.hs
+++ b/Language/Haskell/Tools/BackendGHC/Binds.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE LambdaCase, ViewPatterns #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the value and function definitions of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Binds where
@@ -13,6 +18,7 @@
 import Name as GHC (isSymOcc)
 import PlaceHolder as GHC (NameOrRdrName)
 import SrcLoc as GHC
+import HsExtension (IdP)
 
 import Control.Monad.Reader (Monad(..), mapM, asks)
 import Data.List
@@ -32,17 +38,17 @@
 trfBind :: TransformName n r => Located (HsBind n) -> Trf (Ann AST.UValueBind (Dom r) RangeStage)
 trfBind = trfLocNoSema trfBind'
 
-trfBind' :: TransformName n r => HsBind n -> Trf (AST.UValueBind (Dom r) RangeStage)
+trfBind' :: forall n r . TransformName n r => HsBind n -> Trf (AST.UValueBind (Dom r) RangeStage)
 -- A value binding with a strcitness annotation
 trfBind' (FunBind { fun_id = id, fun_matches = MG { mg_alts = L _ [L _ (Match { m_ctxt = FunRhs { mc_strictness = SrcStrict }, m_pats = [], m_grhss = GRHSs [L _ (GRHS [] expr)] (L _ locals) })]} })
   = do bangLoc <- focusBeforeLoc (srcSpanStart $ getLoc id) $ tokenLoc AnnBang
        AST.USimpleBind <$> annLocNoSema (pure $ combineSrcSpans bangLoc (getLoc id))
-                             (AST.UBangPat <$> copyAnnot AST.UVarPat (define $ trfName id))
+                             (AST.UBangPat <$> copyAnnot AST.UVarPat (define $ trfName @n id))
                        <*> addEmptyScope (addToScope locals (annLocNoSema (combineSrcSpans (getLoc expr) <$> tokenLoc AnnEqual) (AST.UUnguardedRhs <$> trfExpr expr)))
                        <*> addEmptyScope (trfWhereLocalBinds (getLoc expr) locals)
 -- A value binding (not a function)
 trfBind' (FunBind { fun_id = id, fun_matches = MG { mg_alts = L _ [L _ (Match { m_pats = [], m_grhss = GRHSs [L _ (GRHS [] expr)] (L _ locals) })]} })
-  = AST.USimpleBind <$> copyAnnot AST.UVarPat (define $ trfName id)
+  = AST.USimpleBind <$> copyAnnot AST.UVarPat (define $ trfName @n id)
                     <*> addEmptyScope (addToScope locals (annLocNoSema (combineSrcSpans (getLoc expr) <$> tokenLoc AnnEqual) (AST.UUnguardedRhs <$> trfExpr expr)))
                     <*> addEmptyScope (trfWhereLocalBinds (getLoc expr) locals)
 trfBind' (FunBind id (MG (unLoc -> matches) _ _ _) _ _ _)
@@ -54,17 +60,17 @@
 trfBind' (PatSynBind _) = convertionProblem "Pattern synonym bindings should be recognized on the declaration level"
 trfBind' b = unhandledElement "binding" b
 
-trfMatch :: TransformName n r => n -> Located (Match n (LHsExpr n)) -> Trf (Ann AST.UMatch (Dom r) RangeStage)
+trfMatch :: TransformName n r => IdP n -> Located (Match n (LHsExpr n)) -> Trf (Ann AST.UMatch (Dom r) RangeStage)
 trfMatch id = trfLocNoSema (trfMatch' id)
 
-trfMatch' :: TransformName n r => n -> Match n (LHsExpr n) -> Trf (AST.UMatch (Dom r) RangeStage)
-trfMatch' name (Match funid pats _ (GRHSs rhss (unLoc -> locBinds)))
+trfMatch' :: TransformName n r => IdP n -> Match n (LHsExpr n) -> Trf (AST.UMatch (Dom r) RangeStage)
+trfMatch' name (Match funid pats (GRHSs rhss (unLoc -> locBinds)))
   -- TODO: add the optional typ to pats
   = AST.UMatch <$> trfMatchLhs name funid pats
                <*> addToScope pats (addToScope locBinds (trfRhss rhss))
                <*> addToScope pats (trfWhereLocalBinds (collectLocs rhss) locBinds)
 
-trfMatchLhs :: TransformName n r => n -> HsMatchContext (NameOrRdrName n) -> [LPat n] -> Trf (Ann AST.UMatchLhs (Dom r) RangeStage)
+trfMatchLhs :: forall n r . TransformName n r => IdP n -> HsMatchContext (NameOrRdrName (IdP n)) -> [LPat n] -> Trf (Ann AST.UMatchLhs (Dom r) RangeStage)
 trfMatchLhs name fb pats
   = do implicitIdLoc <- mkSrcSpan <$> atTheStart <*> atTheStart
        parenOpLoc <- tokensLoc [AnnOpenP, AnnVal, AnnCloseP]
@@ -78,12 +84,12 @@
        closeLoc <- srcSpanStart <$> (combineSrcSpans <$> tokenLoc AnnEqual <*> tokenLoc AnnVbar)
        args <- mapM trfPattern pats
        let (n, isInfix) = case fb of FunRhs n inf _ -> (n, inf == Infix)
-                                     _ -> let token = if isSymOcc (occName name) && isGoodSrcSpan infixLoc then infixLoc else implicitIdLoc
+                                     _ -> let token = if isSymOcc (occName @n name) && isGoodSrcSpan infixLoc then infixLoc else implicitIdLoc
                                            in (L token name, length pats > 0 && srcSpanStart token >= srcSpanEnd (getLoc (pats !! 0)))
        annLocNoSema (mkSrcSpan <$> atTheStart <*> (pure closeLoc)) $
         case (args, isInfix) of
-           (left:right:rest, True) -> AST.UInfixLhs left <$> define (trfOperator n) <*> pure right <*> makeList " " (pure closeLoc) (pure rest)
-           _                       -> AST.UNormalLhs <$> define (trfName n) <*> makeList " " (pure closeLoc) (pure args)
+           (left:right:rest, True) -> AST.UInfixLhs left <$> define (trfOperator @n n) <*> pure right <*> makeList " " (pure closeLoc) (pure rest)
+           _                       -> AST.UNormalLhs <$> define (trfName @n n) <*> makeList " " (pure closeLoc) (pure args)
 
 trfRhss :: TransformName n r => [Located (GRHS n (LHsExpr n))] -> Trf (Ann AST.URhs (Dom r) RangeStage)
 -- the original location on the GRHS misleadingly contains the local bindings
@@ -139,22 +145,22 @@
                                               <*> nothing " " "" atTheEnd)
   IPBind (Right _) _ -> convertionProblem "trfIpBind: called on typechecked AST"
 
-trfLocalSig :: TransformName n r => Located (Sig n) -> Trf (Ann AST.ULocalBind (Dom r) RangeStage)
+trfLocalSig :: forall n r . TransformName n r => Located (Sig n) -> Trf (Ann AST.ULocalBind (Dom r) RangeStage)
 trfLocalSig = trfLocNoSema $ \case
   ts@(TypeSig {}) -> AST.ULocalSignature <$> annContNoSema (trfTypeSig' ts)
   (FixSig fs) -> AST.ULocalFixity <$> annContNoSema (trfFixitySig fs)
-  (InlineSig name prag) -> AST.ULocalInline <$> trfInlinePragma name prag
+  (InlineSig name prag) -> AST.ULocalInline <$> trfInlinePragma @n name prag
   d -> unhandledElement "local signature" d
 
 trfTypeSig :: TransformName n r => Located (Sig n) -> Trf (Ann AST.UTypeSignature (Dom r) RangeStage)
 trfTypeSig = trfLocNoSema trfTypeSig'
 
-trfTypeSig' :: TransformName n r => Sig n -> Trf (AST.UTypeSignature (Dom r) RangeStage)
+trfTypeSig' :: forall n r . TransformName n r => Sig n -> Trf (AST.UTypeSignature (Dom r) RangeStage)
 trfTypeSig' (TypeSig names typ)
-  = defineTypeVars $ AST.UTypeSignature <$> makeNonemptyList ", " (mapM trfName names) <*> trfType (hsib_body $ hswc_body typ)
+  = defineTypeVars $ AST.UTypeSignature <$> makeNonemptyList ", " (mapM (trfName @n) names) <*> trfType (hsib_body $ hswc_body typ)
 trfTypeSig' ts = unhandledElement "type signature" ts
 
-trfFixitySig :: TransformName n r => FixitySig n -> Trf (AST.UFixitySignature (Dom r) RangeStage)
+trfFixitySig :: forall n r . TransformName n r => FixitySig n -> Trf (AST.UFixitySignature (Dom r) RangeStage)
 trfFixitySig (FixitySig names (Fixity _ prec dir))
   = do precLoc <- tokenLoc AnnVal -- the precedence token or one of the names
        AST.UFixitySignature <$> transformDir dir
@@ -162,23 +168,23 @@
                                    then makeJust <$> (annLocNoSema (return precLoc) $ pure $ AST.Precedence prec)
                                                                                          -- names cannot be empty
                                    else nothing "" " " (return $ srcSpanStart $ getLoc $ head names))
-                            <*> (nonemptyAnnList . nubBy ((==) `on` AST.getRange) <$> mapM trfOperator names)
+                            <*> (nonemptyAnnList . nubBy ((==) `on` AST.getRange) <$> mapM (trfOperator @n) names)
   where transformDir InfixL = directionChar (pure AST.AssocLeft)
         transformDir InfixR = directionChar (pure AST.AssocRight)
         transformDir InfixN = annLocNoSema (srcLocSpan . srcSpanEnd <$> tokenLoc AnnInfix) (pure AST.AssocNone)
 
         directionChar = annLocNoSema ((\l -> mkSrcSpan (updateCol (subtract 1) l) l) . srcSpanEnd <$> tokenLoc AnnInfix)
 
-trfInlinePragma :: TransformName n r => Located n -> InlinePragma -> Trf (Ann AST.UInlinePragma (Dom r) RangeStage)
+trfInlinePragma :: forall n r . TransformName n r => Located (IdP n) -> InlinePragma -> Trf (Ann AST.UInlinePragma (Dom r) RangeStage)
 trfInlinePragma name (InlinePragma _ Inlinable _ phase _)
-  = annContNoSema (AST.UInlinablePragma <$> trfPhase (pure $ srcSpanStart $ getLoc name) phase <*> trfName name)
-trfInlinePragma name (InlinePragma _ NoInline _ _ _) = annContNoSema (AST.UNoInlinePragma <$> trfName name)
+  = annContNoSema (AST.UInlinablePragma <$> trfPhase (pure $ srcSpanStart $ getLoc name) phase <*> trfName @n name)
+trfInlinePragma name (InlinePragma _ NoInline _ _ _) = annContNoSema (AST.UNoInlinePragma <$> trfName @n name)
 trfInlinePragma name (InlinePragma (fromSrcText -> src) Inline _ phase cl)
   = annContNoSema $ do rng <- asks contRange
                        let parts = map getLoc $ splitLocated (L rng src)
                        AST.UInlinePragma <$> trfConlike parts cl
                                          <*> trfPhase (pure $ srcSpanStart (getLoc name)) phase
-                                         <*> trfName name
+                                         <*> trfName @n name
 
 trfPhase :: Trf SrcLoc -> Activation -> Trf (AnnMaybeG AST.UPhaseControl (Dom r) RangeStage)
 trfPhase l AlwaysActive = nothing " " "" l
diff --git a/Language/Haskell/Tools/BackendGHC/Decls.hs b/Language/Haskell/Tools/BackendGHC/Decls.hs
--- a/Language/Haskell/Tools/BackendGHC/Decls.hs
+++ b/Language/Haskell/Tools/BackendGHC/Decls.hs
@@ -1,4 +1,8 @@
-{-# LANGUAGE LambdaCase, ScopedTypeVariables, ViewPatterns #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the declarations of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Decls where
@@ -36,7 +40,7 @@
 
 import Language.Haskell.Tools.AST (Ann, AnnMaybeG, AnnListG, getRange, Dom, RangeStage)
 import qualified Language.Haskell.Tools.AST as AST
-import Language.Haskell.Tools.AST.SemaInfoTypes as AST (nameInfo, mkNoSemanticInfo)
+import Language.Haskell.Tools.AST.SemaInfoTypes as AST (nameInfo, mkNoSemanticInfo, trfImportInfo)
 
 trfDecls :: TransformName n r => [LHsDecl n] -> Trf (AnnListG AST.UDecl (Dom r) RangeStage)
 trfDecls decls = addToCurrentScope decls $ makeIndentedListNewlineBefore atTheEnd (mapM trfDecl decls)
@@ -101,14 +105,16 @@
                           allLocals <- asks localsInScope
                           case allLocals of locals:_ -> liftGhc $ mapM (replaceNamesInDecls (map (^. _1) locals)) decls
                                             [] -> convertionProblem "getDeclsToInsert: empty scope"
-       where replaceNamesInDecls :: [GHC.Name] -> Ann AST.UDecl (Dom RdrName) RangeStage -> GHC.Ghc (Ann AST.UDecl (Dom r) RangeStage)
+       where replaceNamesInDecls :: [GHC.Name] -> Ann AST.UDecl (Dom GhcPs) RangeStage -> GHC.Ghc (Ann AST.UDecl (Dom r) RangeStage)
              replaceNamesInDecls locals = AST.semaTraverse $
-                AST.SemaTrf (pure . (AST.nameInfo .- findName)) pure pure (pure . fmap findName) pure pure pure
-               where findName rdr = fromGHCName $ fromMaybe (convProblem $ "Data definition name not found: " ++ showSDocUnsafe (ppr rdr)
+                AST.SemaTrf (pure . (AST.nameInfo .- findName)) pure pure
+                            (pure . trfImportInfo findName) pure pure pure
+               where findName :: RdrName -> IdP r
+                     findName rdr = fromGHCName $ fromMaybe (convProblem $ "Data definition name not found: " ++ showSDocUnsafe (ppr rdr)
                                                                              ++ ", locals: " ++ (concat $ intersperse ", " $ map (showSDocUnsafe . ppr) locals))
                                                 $ find ((occNameString (rdrNameOcc rdr) ==) . occNameString . nameOccName) locals
 
-trfDecl :: TransformName n r => Located (HsDecl n) -> Trf (Ann AST.UDecl (Dom r) RangeStage)
+trfDecl :: forall n r . TransformName n r => Located (HsDecl n) -> Trf (Ann AST.UDecl (Dom r) RangeStage)
 trfDecl = trfLocNoSema $ \case
   TyClD (FamDecl (FamilyDecl (ClosedTypeFamily typeEqs) name tyVars _ kindSig inj))
     -> AST.UClosedTypeFamilyDecl <$> focusAfter AnnType (createDeclHead name tyVars)
@@ -127,53 +133,53 @@
   TyClD (ClassDecl ctx name vars _ funDeps sigs defs typeFuns typeFunDefs _ _)
     -> AST.UClassDecl <$> trfCtx (after AnnClass) ctx
                      <*> betweenIfPresent AnnClass AnnWhere (createDeclHead name vars)
-                     <*> trfFunDeps funDeps
+                     <*> trfFunDeps @n funDeps
                      <*> createClassBody sigs defs typeFuns typeFunDefs
   InstD (ClsInstD (ClsInstDecl typ binds sigs typefam datafam overlap))
     -> AST.UInstDecl <$> trfMaybeDefault " " "" trfOverlap (after AnnInstance) overlap
                     <*> trfInstanceRule (hsib_body typ)
                     <*> trfInstBody binds sigs typefam datafam
-  InstD (DataFamInstD (DataFamInstDecl con pats _ (HsDataDefn nd _ _ _ cons derivs) _))
+  InstD (DataFamInstD (DataFamInstDecl (hsib_body -> FamEqn con pats _ (HsDataDefn nd _ _ _ cons derivs))))
     | all ((\case ConDeclH98{} -> True; _ -> False) . unLoc) cons
     -> AST.UDataInstDecl <$> trfDataKeyword nd
                         <*> (focusAfter AnnInstance . focusBeforeIfPresent AnnEqual . focusBeforeIfPresent AnnDeriving)
                               (makeInstanceRuleTyVars con pats)
                                                        -- the location is needed when there is no = sign
-                        <*> makeListBefore " = " " | " (pure $ srcSpanStart $ foldLocs $ getLoc con : map getLoc (hsib_body pats)) (mapM trfConDecl cons)
+                        <*> makeListBefore " = " " | " (pure $ srcSpanStart $ foldLocs $ getLoc con : map getLoc pats) (mapM trfConDecl cons)
                         <*> makeIndentedList atTheEnd (mapM trfDerivings (unLoc derivs))
-  InstD (DataFamInstD (DataFamInstDecl con pats _ (HsDataDefn nd _ _ kind cons _) _))
+  InstD (DataFamInstD (DataFamInstDecl (hsib_body -> FamEqn con pats _ (HsDataDefn nd _ _ kind cons _))))
     -> AST.UGDataInstDecl <$> trfDataKeyword nd
                         <*> (focusAfter AnnInstance . focusBeforeIfPresent AnnWhere)
                               (makeInstanceRuleTyVars con pats)
                         <*> focusBefore AnnWhere (trfKindSig kind)
                         <*> makeIndentedListBefore " where " atTheEnd (mapM trfGADTConDecl cons)
-  InstD (TyFamInstD (TyFamInstDecl (L _ (TyFamEqn con pats _ rhs)) _))
+  InstD (TyFamInstD (TyFamInstDecl (hsib_body -> FamEqn con pats _ rhs)))
     -> AST.UTypeInstDecl <$> between AnnInstance AnnEqual (makeInstanceRuleTyVars con pats) <*> trfType rhs
   ValD bind -> trfVal bind
   SigD sig -> trfSig sig
   DerivD (DerivDecl t strat overlap) -> AST.UDerivDecl <$> trfDerivingStrategy strat <*> trfMaybeDefault " " "" trfOverlap (after AnnInstance) overlap <*> trfInstanceRule (hsib_body t)
   RuleD (HsRules _ rules) -> AST.UPragmaDecl <$> annContNoSema (AST.URulePragma <$> makeIndentedList (before AnnClose) (mapM trfRewriteRule rules))
-  RoleAnnotD (RoleAnnotDecl name roles) -> AST.URoleDecl <$> trfQualifiedName False name <*> makeList " " atTheEnd (mapM trfRole roles)
+  RoleAnnotD (RoleAnnotDecl name roles) -> AST.URoleDecl <$> trfQualifiedName @n False name <*> makeList " " atTheEnd (mapM trfRole roles)
   DefD (DefaultDecl types) -> AST.UDefaultDecl <$> makeList "," (after AnnOpenP) (mapM trfType types)
   ForD (ForeignImport name (hsib_body -> typ) _ (CImport ccall safe _ _ _))
-    -> AST.UForeignImport <$> trfCallConv ccall <*> trfSafety (getLoc ccall) safe <*> define (trfName name) <*> trfType typ
+    -> AST.UForeignImport <$> trfCallConv ccall <*> trfSafety (getLoc ccall) safe <*> define (trfName @n name) <*> trfType typ
   ForD (ForeignExport name (hsib_body -> typ) _ (CExport (L l (CExportStatic _ _ ccall)) _))
-    -> AST.UForeignExport <$> annLocNoSema (pure l) (trfCallConv' ccall) <*> trfName name <*> trfType typ
+    -> AST.UForeignExport <$> annLocNoSema (pure l) (trfCallConv' ccall) <*> trfName @n name <*> trfType typ
   SpliceD (SpliceDecl (unLoc -> spl) _) -> AST.USpliceDecl <$> trfSplice spl
   WarningD (Warnings _ [])
     -> AST.UPragmaDecl <$> annContNoSema (AST.UDeprPragma <$> (makeList " " (after AnnOpen) (pure []))
                                                           <*> makeList ", " (before AnnClose) (pure []))
   WarningD (Warnings _ [L _ (Warning names (DeprecatedTxt _ stringLits))])
-    -> AST.UPragmaDecl <$> annContNoSema (AST.UDeprPragma <$> (makeList " " (after AnnOpen) $ mapM trfName names)
+    -> AST.UPragmaDecl <$> annContNoSema (AST.UDeprPragma <$> (makeList " " (after AnnOpen) $ mapM (trfName @n) names)
                                                           <*> makeList ", " (before AnnClose) (mapM (\(L l (StringLiteral _ fs)) -> trfFastString (L l fs)) stringLits))
   WarningD (Warnings _ [L _ (Warning names (WarningTxt _ stringLits))])
-    -> AST.UPragmaDecl <$> annContNoSema (AST.UWarningPragma <$> (makeNonemptyList " " $ mapM trfName names)
+    -> AST.UPragmaDecl <$> annContNoSema (AST.UWarningPragma <$> (makeNonemptyList " " $ mapM (trfName @n) names)
                                                              <*> makeList ", " (before AnnClose) (mapM (\(L l (StringLiteral _ fs)) -> trfFastString (L l fs)) stringLits))
   AnnD (HsAnnotation stxt subject expr)
-    -> AST.UPragmaDecl <$> annContNoSema (AST.UAnnPragma <$> trfAnnotationSubject stxt subject (srcSpanStart $ getLoc expr) <*> trfExpr expr)
+    -> AST.UPragmaDecl <$> annContNoSema (AST.UAnnPragma <$> trfAnnotationSubject @n stxt subject (srcSpanStart $ getLoc expr) <*> trfExpr expr)
   d -> unhandledElement "declaration" d
 
-trfGADT :: TransformName n r => NewOrData -> Located n -> LHsQTyVars n -> Located (HsContext n)
+trfGADT :: TransformName n r => NewOrData -> Located (IdP n) -> LHsQTyVars n -> Located (HsContext n)
                                  -> Maybe (Located (HsKind n)) -> [Located (ConDecl n)]
                                  -> Located [LHsDerivingClause n] -> AnnKeywordId -> Trf SrcLoc -> Trf (AST.UDecl (Dom r) RangeStage)
 trfGADT nd name vars ctx kind cons derivs ctxTok consLoc
@@ -184,7 +190,7 @@
                    <*> makeIndentedListBefore " where " consLoc (mapM trfGADTConDecl cons)
                    <*> makeIndentedList atTheEnd (mapM trfDerivings (unLoc derivs))
 
-trfDataDef :: TransformName n r => NewOrData -> Located n -> LHsQTyVars n -> Located (HsContext n)
+trfDataDef :: TransformName n r => NewOrData -> Located (IdP n) -> LHsQTyVars n -> Located (HsContext n)
                                      -> [Located (ConDecl n)] -> Located [LHsDerivingClause n]
                                      -> AnnKeywordId -> Trf SrcLoc -> Trf (AST.UDecl (Dom r) RangeStage)
 trfDataDef nd name vars ctx cons derivs ctxTok consLoc
@@ -198,37 +204,37 @@
 trfVal (PatSynBind psb) = AST.UPatternSynonymDecl <$> annContNoSema (trfPatternSynonym psb)
 trfVal bind = AST.UValueBinding <$> (annContNoSema $ trfBind' bind)
 
-trfSig :: TransformName n r => Sig n -> Trf (AST.UDecl (Dom r) RangeStage)
-trfSig (ts @ (TypeSig {})) = AST.UTypeSigDecl <$> defineTypeVars (annContNoSema $ trfTypeSig' ts)
+trfSig :: forall n r . TransformName n r => Sig n -> Trf (AST.UDecl (Dom r) RangeStage)
+trfSig (ts@TypeSig {}) = AST.UTypeSigDecl <$> defineTypeVars (annContNoSema $ trfTypeSig' ts)
 trfSig (FixSig fs) = AST.UFixityDecl <$> (annContNoSema $ trfFixitySig fs)
 trfSig (PatSynSig ids typ)
-  = AST.UPatTypeSigDecl <$> annContNoSema (AST.UPatternTypeSignature <$> trfAnnList ", " trfName' ids <*> trfType (hsib_body typ))
+  = AST.UPatTypeSigDecl <$> annContNoSema (AST.UPatternTypeSignature <$> trfAnnList ", " (trfName' @n) ids <*> trfType (hsib_body typ))
 trfSig (InlineSig name prag)
-  = AST.UPragmaDecl <$> annContNoSema (AST.UInlinePragmaDecl <$> trfInlinePragma name prag)
+  = AST.UPragmaDecl <$> annContNoSema (AST.UInlinePragmaDecl <$> trfInlinePragma @n name prag)
 trfSig (SpecSig name (map hsib_body -> types) (inl_act -> phase))
   = AST.UPragmaDecl <$> annContNoSema (AST.USpecializeDecl <$> trfSpecializePragma name types phase)
 trfSig (CompleteMatchSig _ names typeConstraint)
-  = AST.UPragmaDecl <$> annContNoSema (AST.UCompletePragma <$> trfAnnList ", " trfName' (unLoc names)
-                                                           <*> trfMaybe " :: " "" trfName typeConstraint)
+  = AST.UPragmaDecl <$> annContNoSema (AST.UCompletePragma <$> trfAnnList ", " (trfName' @n) (unLoc names)
+                                                           <*> trfMaybe " :: " "" (trfName @n) typeConstraint)
 trfSig s = unhandledElement "signature" s
 
-trfSpecializePragma :: TransformName n r
-                    => Located n -> [Located (HsType n)] -> Activation -> Trf (Ann AST.USpecializePragma (Dom r) RangeStage)
+trfSpecializePragma :: forall n r . TransformName n r
+                    => Located (IdP n) -> [Located (HsType n)] -> Activation -> Trf (Ann AST.USpecializePragma (Dom r) RangeStage)
 trfSpecializePragma name types phase
   = annContNoSema $ AST.USpecializePragma <$> trfPhase (pure $ srcSpanStart (getLoc name)) phase
-                                          <*> trfName name
+                                          <*> trfName @n name
                                           <*> (orderAnnList <$> trfAnnList ", " trfType' types)
 
 trfConDecl :: TransformName n r => Located (ConDecl n) -> Trf (Ann AST.UConDecl (Dom r) RangeStage)
 trfConDecl = trfLocNoSema trfConDecl'
 
-trfConDecl' :: TransformName n r => ConDecl n -> Trf (AST.UConDecl (Dom r) RangeStage)
+trfConDecl' :: forall n r . TransformName n r => ConDecl n -> Trf (AST.UConDecl (Dom r) RangeStage)
 trfConDecl' (ConDeclH98 { con_name = name, con_qvars = tyVars, con_cxt = ctx, con_details = PrefixCon args })
-  = AST.UConDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> define (trfName name) <*> makeList " " atTheEnd (mapM trfType args)
+  = AST.UConDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> define (trfName @n name) <*> makeList " " atTheEnd (mapM trfType args)
 trfConDecl' (ConDeclH98 { con_name = name, con_qvars = tyVars, con_cxt = ctx, con_details = RecCon (unLoc -> flds) })
-  = AST.URecordDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> define (trfName name) <*> (between AnnOpenC AnnCloseC $ trfAnnList ", " trfFieldDecl' flds)
+  = AST.URecordDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> define (trfName @n name) <*> (between AnnOpenC AnnCloseC $ trfAnnList ", " trfFieldDecl' flds)
 trfConDecl' (ConDeclH98 { con_name = name, con_qvars = tyVars, con_cxt = ctx, con_details = InfixCon t1 t2 })
-  = AST.UInfixConDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> trfType t1 <*> define (trfOperator name) <*> trfType t2
+  = AST.UInfixConDecl <$> trfConTyVars tyVars <*> trfConCtx ctx <*> trfType t1 <*> define (trfOperator @n name) <*> trfType t2
 trfConDecl' gadt@(ConDeclGADT {}) = unhandledElement "normal constructor declaration" gadt
 
 trfConTyVars :: TransformName n r => Maybe (LHsQTyVars n) -> Trf (AnnListG AST.UTyVar (Dom r) RangeStage)
@@ -242,12 +248,12 @@
 trfGADTConDecl :: TransformName n r => Located (ConDecl n) -> Trf (Ann AST.UGadtConDecl (Dom r) RangeStage)
 trfGADTConDecl = trfLocNoSema trfGADTConDecl'
 
-trfGADTConDecl' :: TransformName n r => ConDecl n -> Trf (AST.UGadtConDecl (Dom r) RangeStage)
+trfGADTConDecl' :: forall n r . TransformName n r => ConDecl n -> Trf (AST.UGadtConDecl (Dom r) RangeStage)
 trfGADTConDecl' (ConDeclGADT { con_names = names, con_type = hsib_body -> typ })
   = let nameLoc = collectLocs names
         typLoc = getLoc typ
         (vars, ctx, t) = getTypeVarsAndCtx typ
-     in AST.UGadtConDecl <$> define (trfAnnList ", " trfName' names)
+     in AST.UGadtConDecl <$> define (trfAnnList ", " (trfName' @n) names)
                          <*> focusOn (mkSrcSpan (srcSpanEnd nameLoc) (srcSpanStart typLoc)) (trfBindings vars)
                          <*> updateFocus (return . updateEnd (\_ -> srcSpanStart typLoc)) (focusAfterIfPresent AnnDot (trfCtx atTheStart ctx))
                          <*> trfGadtConType t
@@ -267,8 +273,8 @@
 trfFieldDecl :: TransformName n r => Located (ConDeclField n) -> Trf (Ann AST.UFieldDecl (Dom r) RangeStage)
 trfFieldDecl = trfLocNoSema trfFieldDecl'
 
-trfFieldDecl' :: TransformName n r => ConDeclField n -> Trf (AST.UFieldDecl (Dom r) RangeStage)
-trfFieldDecl' (ConDeclField names typ _) = AST.UFieldDecl <$> (define $ nonemptyAnnList <$> mapM (trfName . getFieldOccName) names) <*> trfType typ
+trfFieldDecl' :: forall n r . TransformName n r => ConDeclField n -> Trf (AST.UFieldDecl (Dom r) RangeStage)
+trfFieldDecl' (ConDeclField names typ _) = AST.UFieldDecl <$> (define $ nonemptyAnnList <$> mapM (trfName @n . getFieldOccName) names) <*> trfType typ
 
 trfDerivings :: TransformName n r => Located (HsDerivingClause n) -> Trf (Ann AST.UDeriving (Dom r) RangeStage)
 trfDerivings = trfLocNoSema $ \case
@@ -287,7 +293,7 @@
 trfInstanceRule :: TransformName n r => Located (HsType n) -> Trf (Ann AST.UInstanceRule (Dom r) RangeStage)
 trfInstanceRule = trfLocNoSema (trfInstanceRule' . cleanHsType)
 
-trfInstanceRule' :: TransformName n r => HsType n -> Trf (AST.UInstanceRule (Dom r) RangeStage)
+trfInstanceRule' :: forall n r . TransformName n r => HsType n -> Trf (AST.UInstanceRule (Dom r) RangeStage)
 trfInstanceRule' (HsForAllTy bndrs (unLoc -> HsQualTy ctx typ))
   = AST.UInstanceRule <$> (makeJust <$> annLocNoSema (pure $ collectLocs bndrs) (trfBindings bndrs))
                       <*> trfCtx (after AnnDot) ctx
@@ -296,45 +302,45 @@
                                                         <*> trfCtx atTheStart ctx
                                                         <*> trfInstanceHead typ
 trfInstanceRule' (HsParTy typ) = instanceHead $ annContNoSema (AST.UInstanceHeadParen <$> trfInstanceHead typ)
-trfInstanceRule' (HsTyVar _ tv) = instanceHead $ annContNoSema (AST.UInstanceHeadCon <$> trfName tv)
+trfInstanceRule' (HsTyVar _ tv) = instanceHead $ annContNoSema (AST.UInstanceHeadCon <$> trfName @n tv)
 trfInstanceRule' (HsAppTy t1 t2) = instanceHead $ annContNoSema (AST.UInstanceHeadApp <$> trfInstanceHead t1 <*> trfType t2)
-trfInstanceRule' (HsOpTy t1 op t2) = instanceHead $ annContNoSema (AST.UInstanceHeadApp <$> annLocNoSema (pure $ getLoc t1 `combineSrcSpans` getLoc op) (AST.UInstanceHeadInfix <$> trfType t1 <*> trfOperator op) <*> trfType t2)
+trfInstanceRule' (HsOpTy t1 op t2) = instanceHead $ annContNoSema (AST.UInstanceHeadApp <$> annLocNoSema (pure $ getLoc t1 `combineSrcSpans` getLoc op) (AST.UInstanceHeadInfix <$> trfType t1 <*> trfOperator @n op) <*> trfType t2)
 trfInstanceRule' t = unhandledElement "instance rule" t
 
 instanceHead :: Trf (Ann AST.UInstanceHead (Dom r) RangeStage) -> Trf (AST.UInstanceRule (Dom r) RangeStage)
 instanceHead hd = AST.UInstanceRule <$> (nothing "" " . " atTheStart) <*> (nothing " " "" atTheStart) <*> hd
 
-makeInstanceRuleTyVars :: TransformName n r => Located n -> HsImplicitBndrs n [LHsType n] -> Trf (Ann AST.UInstanceRule (Dom r) RangeStage)
+makeInstanceRuleTyVars :: forall n r . TransformName n r => Located (IdP n) -> [LHsType n] -> Trf (Ann AST.UInstanceRule (Dom r) RangeStage)
 makeInstanceRuleTyVars n vars
-  | isSymOcc (occName (unLoc n))
-  , leftOp:rest <- hsib_body vars
+  | isSymOcc (occName @n (unLoc n))
+  , leftOp:rest <- vars
   , srcSpanStart (getLoc n) > srcSpanEnd (getLoc leftOp)
   = annContNoSema
       $ AST.UInstanceRule <$> nothing "" " . " atTheStart
                           <*> nothing " " "" atTheStart
                           <*> foldl foldTypeArgs
                                     (annLocNoSema (pure $ combineSrcSpans (getLoc leftOp) (getLoc n))
-                                      (AST.UInstanceHeadInfix <$> trfType leftOp <*> trfOperator n)) rest
+                                      (AST.UInstanceHeadInfix <$> trfType leftOp <*> trfOperator @n n)) rest
   | otherwise
   = annContNoSema
       $ AST.UInstanceRule <$> nothing "" " . " atTheStart
                           <*> nothing " " "" atTheStart
-                          <*> foldl foldTypeArgs (copyAnnot AST.UInstanceHeadCon (trfName n)) (hsib_body vars)
+                          <*> foldl foldTypeArgs (copyAnnot AST.UInstanceHeadCon (trfName @n n)) vars
   where foldTypeArgs base typ = annLocNoSema (pure $ combineSrcSpans (getLoc n) (getLoc typ)) $ AST.UInstanceHeadApp <$> base <*> (trfType typ)
 
 
 trfInstanceHead :: TransformName n r => Located (HsType n) -> Trf (Ann AST.UInstanceHead (Dom r) RangeStage)
 trfInstanceHead = trfLocNoSema trfInstanceHead'
 
-trfInstanceHead' :: TransformName n r => HsType n -> Trf (AST.UInstanceHead (Dom r) RangeStage)
+trfInstanceHead' :: forall n r . TransformName n r => HsType n -> Trf (AST.UInstanceHead (Dom r) RangeStage)
 trfInstanceHead' = trfInstanceHead'' . cleanHsType where
   trfInstanceHead'' (HsForAllTy [] (unLoc -> t)) = trfInstanceHead' t
-  trfInstanceHead'' (HsTyVar _ tv) = AST.UInstanceHeadCon <$> trfName tv
+  trfInstanceHead'' (HsTyVar _ tv) = AST.UInstanceHeadCon <$> trfName @n tv
   trfInstanceHead'' (HsAppTy t1 t2) = AST.UInstanceHeadApp <$> trfInstanceHead t1 <*> trfType t2
   trfInstanceHead'' (HsParTy typ) = AST.UInstanceHeadParen <$> trfInstanceHead typ
   trfInstanceHead'' (HsOpTy t1 op t2)
     = AST.UInstanceHeadApp <$> (annLocNoSema (pure $ combineSrcSpans (getLoc t1) (getLoc op))
-                                             (AST.UInstanceHeadInfix <$> trfType t1 <*> trfOperator op))
+                                             (AST.UInstanceHeadInfix <$> trfType t1 <*> trfOperator @n op))
                           <*> trfType t2
   trfInstanceHead'' t = unhandledElement "instance head" t
 
@@ -342,39 +348,40 @@
 trfTypeEqs eqs =
   do toks <- tokensAfter AnnWhere
      case toks of [] -> convertionProblem "trfTypeEqs: no where found after closed type family"
-                  loc:_ -> makeList "\n" (pure $ srcSpanStart loc) (mapM trfTypeEq (fromMaybe [] eqs))
+                  loc:_ -> makeList "\n" (pure $ srcSpanStart loc) (mapM (trfTypeEq . fmap hsib_body) (fromMaybe [] eqs))
 
-trfTypeEq :: TransformName n r => Located (TyFamInstEqn n) -> Trf (Ann AST.UTypeEqn (Dom r) RangeStage)
-trfTypeEq = trfLocNoSema $ \(TyFamEqn name pats _ rhs)
-  -> AST.UTypeEqn <$> defineTypeVars (focusBefore AnnEqual (combineTypes name (hsib_body pats))) <*> trfType rhs
-  where combineTypes :: TransformName n r => Located n -> [LHsType n] -> Trf (Ann AST.UType (Dom r) RangeStage)
+trfTypeEq :: forall n r . TransformName n r => Located (FamEqn n (HsTyPats n) (LHsType n)) -> Trf (Ann AST.UTypeEqn (Dom r) RangeStage)
+trfTypeEq = trfLocNoSema $ \(FamEqn name pats _ rhs)
+  -> AST.UTypeEqn <$> defineTypeVars (focusBefore AnnEqual (combineTypes name pats)) <*> trfType rhs
+  where combineTypes :: Located (IdP n) -> [LHsType n] -> Trf (Ann AST.UType (Dom r) RangeStage)
         combineTypes name [lhs, rhs] | srcSpanStart (getLoc name) > srcSpanEnd (getLoc lhs)
-          = annContNoSema $ AST.UTyInfix <$> trfType lhs <*> trfOperator name <*> trfType rhs
-        combineTypes name pats = wrapTypes (annLocNoSema (pure $ getLoc name) (AST.UTyVar <$> trfName name)) pats
+          = annContNoSema $ AST.UTyInfix <$> trfType lhs <*> trfOperator @n name <*> trfType rhs
+        combineTypes name pats = wrapTypes (annLocNoSema (pure $ getLoc name) (AST.UTyVar <$> trfName @n name)) pats
 
-        wrapTypes :: TransformName n r => Trf (Ann AST.UType (Dom r) RangeStage) -> [LHsType n] -> Trf (Ann AST.UType (Dom r) RangeStage)
+        wrapTypes :: Trf (Ann AST.UType (Dom r) RangeStage) -> [LHsType n] -> Trf (Ann AST.UType (Dom r) RangeStage)
         wrapTypes base pats
           = foldl (\t p -> do typ <- t
                               annLocNoSema (pure $ combineSrcSpans (getRange typ) (getLoc p))
                                      (AST.UTyApp <$> pure typ <*> trfType p)) base pats
 
-trfFunDeps :: TransformName n r => [Located (FunDep (Located n))] -> Trf (AnnMaybeG AST.UFunDeps (Dom r) RangeStage)
+trfFunDeps :: forall n r . TransformName n r
+           => [Located (FunDep (Located (IdP n)))] -> Trf (AnnMaybeG AST.UFunDeps (Dom r) RangeStage)
 trfFunDeps [] = do whereToken <- tokenLoc AnnWhere
                    nothing "| " "" (if isGoodSrcSpan whereToken then pure $ srcSpanStart whereToken else atTheEnd)
 trfFunDeps fundeps = makeJust <$> annLocNoSema (combineSrcSpans (collectLocs fundeps) <$> tokenLoc AnnVbar)
-                                         (AST.UFunDeps <$> trfAnnList ", " trfFunDep' fundeps)
+                                         (AST.UFunDeps <$> trfAnnList ", " (trfFunDep' @n) fundeps)
 
-trfFunDep' :: TransformName n r => FunDep (Located n) -> Trf (AST.UFunDep (Dom r) RangeStage)
-trfFunDep' (lhs, rhs) = AST.UFunDep <$> trfAnnList ", " trfName' lhs <*> trfAnnList ", " trfName' rhs
+trfFunDep' :: forall n r . TransformName n r => FunDep (Located (IdP n)) -> Trf (AST.UFunDep (Dom r) RangeStage)
+trfFunDep' (lhs, rhs) = AST.UFunDep <$> trfAnnList ", " (trfName' @n) lhs <*> trfAnnList ", " (trfName' @n) rhs
 
-createDeclHead :: TransformName n r => Located n -> LHsQTyVars n -> Trf (Ann AST.UDeclHead (Dom r) RangeStage)
+createDeclHead :: forall n r . TransformName n r => Located (IdP n) -> LHsQTyVars n -> Trf (Ann AST.UDeclHead (Dom r) RangeStage)
 createDeclHead name (hsq_explicit -> lhs : rhs : rest)
   | srcSpanStart (getLoc name) > srcSpanEnd (getLoc lhs)
   -- infix declaration
   = wrapDeclHead rest
       $ annLocNoSema (addParenLocs $ getLoc lhs `combineSrcSpans` getLoc rhs)
-                     (AST.UDHInfix <$> defineTypeVars (trfTyVar lhs) <*> define (trfOperator name) <*> defineTypeVars (trfTyVar rhs))
-createDeclHead name vars = defineTypeVars $ wrapDeclHead (hsq_explicit vars) (define $ copyAnnot AST.UDeclHead (trfName name))
+                     (AST.UDHInfix <$> defineTypeVars (trfTyVar lhs) <*> define (trfOperator @n name) <*> defineTypeVars (trfTyVar rhs))
+createDeclHead name vars = defineTypeVars $ wrapDeclHead (hsq_explicit vars) (define $ copyAnnot AST.UDeclHead (trfName @n name))
 
 wrapDeclHead :: TransformName n r => [LHsTyVarBndr n] -> Trf (Ann AST.UDeclHead (Dom r) RangeStage) -> Trf (Ann AST.UDeclHead (Dom r) RangeStage)
 wrapDeclHead vars base
@@ -408,15 +415,15 @@
         getFams = mapM (copyAnnot AST.UClsTypeFam . trfTypeFam) typeFams
         getFamDefs = mapM trfTypeFamDef typeFamDefs
 
-trfClassElemSig :: TransformName n r => Located (Sig n) -> Trf (Ann AST.UClassElement (Dom r) RangeStage)
+trfClassElemSig :: forall n r . TransformName n r => Located (Sig n) -> Trf (Ann AST.UClassElement (Dom r) RangeStage)
 trfClassElemSig = trfLocNoSema $ \case
-  TypeSig names typ -> AST.UClsSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM trfName names))
+  TypeSig names typ -> AST.UClsSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM (trfName @n) names))
                                   <*> trfType (hsib_body $ hswc_body typ))
-  ClassOpSig True [name] typ -> AST.UClsDefSig <$> trfName name <*> trfType (hsib_body typ)
-  ClassOpSig False names typ -> AST.UClsSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM trfName names))
+  ClassOpSig True [name] typ -> AST.UClsDefSig <$> trfName @n name <*> trfType (hsib_body typ)
+  ClassOpSig False names typ -> AST.UClsSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM (trfName @n) names))
                                            <*> trfType (hsib_body typ))
-  MinimalSig _ formula -> AST.UClsMinimal <$> trfMinimalFormula formula
-  InlineSig name prag -> AST.UClsInline <$> trfInlinePragma name prag
+  MinimalSig _ formula -> AST.UClsMinimal <$> trfMinimalFormula @n formula
+  InlineSig name prag -> AST.UClsInline <$> trfInlinePragma @n name prag
   FixSig fixity -> AST.UClsFixity <$> annContNoSema (trfFixitySig fixity)
   s -> unhandledElement "signature in class" s
 
@@ -433,7 +440,7 @@
 trfTypeFam' (FamilyDecl (ClosedTypeFamily {}) _ _ _ _ _) = convertionProblem "trfTypeFam': closed type family received"
 
 trfTypeFamDef :: TransformName n r => Located (TyFamDefltEqn n) -> Trf (Ann AST.UClassElement (Dom r) RangeStage)
-trfTypeFamDef = trfLocNoSema $ \(TyFamEqn con pats _ rhs)
+trfTypeFamDef = trfLocNoSema $ \(FamEqn con pats _ rhs)
   -> AST.UClsTypeDef <$> between AnnType AnnEqual (createDeclHead con pats) <*> trfType rhs
 
 trfInstBody :: TransformName n r => LHsBinds n -> [LSig n] -> [LTyFamInstDecl n] -> [LDataFamInstDecl n] -> Trf (AnnMaybeG AST.UInstBody (Dom r) RangeStage)
@@ -452,23 +459,23 @@
         getFams = mapM trfInstTypeFam fams
         getDats = mapM trfInstDataFam dats
 
-trfClassInstSig :: TransformName n r => Located (Sig n) -> Trf (Ann AST.UInstBodyDecl (Dom r) RangeStage)
+trfClassInstSig :: forall n r . TransformName n r => Located (Sig n) -> Trf (Ann AST.UInstBodyDecl (Dom r) RangeStage)
 trfClassInstSig = trfLocNoSema $ \case
-  TypeSig names typ -> AST.UInstBodyTypeSig <$> (annContNoSema $ AST.UTypeSignature <$> makeNonemptyList ", " (mapM trfName names)
+  TypeSig names typ -> AST.UInstBodyTypeSig <$> (annContNoSema $ AST.UTypeSignature <$> makeNonemptyList ", " (mapM (trfName @n) names)
                                            <*> trfType (hsib_body $ hswc_body typ))
-  ClassOpSig _ names typ -> AST.UInstBodyTypeSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM trfName names))
+  ClassOpSig _ names typ -> AST.UInstBodyTypeSig <$> (annContNoSema $ AST.UTypeSignature <$> define (makeNonemptyList ", " (mapM (trfName @n) names))
                                                 <*> trfType (hsib_body typ))
   SpecInstSig _ typ -> AST.USpecializeInstance <$> trfType (hsib_body typ)
   SpecSig name (map hsib_body -> tys) (inl_act -> phase) -> AST.UInstanceSpecialize <$> trfSpecializePragma name tys phase
-  InlineSig name prag -> AST.UInlineInstance <$> trfInlinePragma name prag
+  InlineSig name prag -> AST.UInlineInstance <$> trfInlinePragma @n name prag
   s -> unhandledElement "class instance signature" s
 
 trfInstTypeFam :: TransformName n r => Located (TyFamInstDecl n) -> Trf (Ann AST.UInstBodyDecl (Dom r) RangeStage)
-trfInstTypeFam (unLoc -> TyFamInstDecl eqn _) = copyAnnot AST.UInstBodyTypeDecl (trfTypeEq eqn)
+trfInstTypeFam (L l (TyFamInstDecl (hsib_body -> eqn))) = copyAnnot AST.UInstBodyTypeDecl (trfTypeEq (L l eqn))
 
-trfInstDataFam :: TransformName n r => Located (DataFamInstDecl n) -> Trf (Ann AST.UInstBodyDecl (Dom r) RangeStage)
+trfInstDataFam :: forall n r . TransformName n r => Located (DataFamInstDecl n) -> Trf (Ann AST.UInstBodyDecl (Dom r) RangeStage)
 trfInstDataFam = trfLocNoSema $ \case
-  (DataFamInstDecl tc (hsib_body -> pats) _ (HsDataDefn dn ctx _ ks cons derivs) _)
+  (DataFamInstDecl (hsib_body -> FamEqn tc pats _ (HsDataDefn dn ctx _ ks cons derivs)))
     | all ((\case ConDeclH98{} -> True; _ -> False) . unLoc) cons
     -> AST.UInstBodyDataDecl
          <$> trfDataKeyword dn
@@ -488,17 +495,18 @@
         <*> trfKindSig ks
         <*> trfAnnList "" trfGADTConDecl' cons
         <*> makeIndentedList atTheEnd (mapM trfDerivings (unLoc derivs))
-  where transformNameAndPats tc pats -- TODO: this is simpler with lexical fixity
+  where transformNameAndPats :: Located (IdP n) -> [LHsType n] -> Trf (Ann AST.UInstanceHead (Dom r) RangeStage)
+        transformNameAndPats tc pats -- TODO: this is simpler with lexical fixity
           | all (\p -> srcSpanEnd (getLoc tc) < srcSpanStart (getLoc p)) pats -- prefix instance head application
           = foldl (\r t -> annLocNoSema (combineSrcSpans (getLoc t) . getRange <$> r)
                                           (AST.UInstanceHeadApp <$> r <*> (trfType t)))
-                  (copyAnnot AST.UInstanceHeadCon (trfName tc)) pats
+                  (copyAnnot AST.UInstanceHeadCon (trfName @n tc)) pats
         transformNameAndPats tc (p:rest)
           | otherwise -- infix instance head application
           = foldl (\r t -> annLocNoSema (combineSrcSpans (getLoc t) . getRange <$> r)
                                           (AST.UInstanceHeadApp <$> r <*> (trfType t)))
                   (annLocNoSema (pure $ getLoc p `combineSrcSpans` getLoc tc)
-                          (AST.UInstanceHeadInfix <$> trfType p <*> trfOperator tc)) rest
+                          (AST.UInstanceHeadInfix <$> trfType p <*> trfOperator @n tc)) rest
 
 trfPatternSynonym :: forall n r . TransformName n r => PatSynBind n n -> Trf (AST.UPatternSynonym (Dom r) RangeStage)
 trfPatternSynonym (PSB id _ lhs def dir)
@@ -506,20 +514,20 @@
                           _                     -> AnnLarrow
         rhsLoc = combineSrcSpans (getLoc def) <$> tokenLoc sep
         -- we use the selector name instead of the pattern variable name
-        rewrites = case lhs of RecordPatSyn flds -> map (\r -> (unLoc (recordPatSynPatVar r), unLoc (recordPatSynSelectorId r))) flds
-                               _                 -> []
+        rewrites = case lhs of RecCon flds -> map (\r -> (unLoc (recordPatSynPatVar r), unLoc (recordPatSynSelectorId r))) flds
+                               _           -> []
         changedRhs = biplateRef .- (\n -> case lookup n rewrites of Just x -> x; Nothing -> n) $ def
      in AST.UPatternSynonym <$> trfPatSynLhs id lhs sep
                             <*> annLocNoSema rhsLoc (trfPatSynRhs dir changedRhs)
 
-  where trfPatSynLhs :: Located n -> HsPatSynDetails (Located n) -> AnnKeywordId -> Trf (Ann AST.UPatSynLhs (Dom r) RangeStage)
-        trfPatSynLhs id (PrefixPatSyn args) _
-          = annLocNoSema (pure $ foldLocs (getLoc id : map getLoc args)) $ AST.UNormalPatSyn <$> define (trfName id) <*> trfAnnList " " trfName' args
-        trfPatSynLhs op (InfixPatSyn lhs rhs) _
-          = annLocNoSema (pure $ getLoc lhs `combineSrcSpans` getLoc rhs) $ AST.UInfixPatSyn <$> define (trfName lhs) <*> trfOperator op <*> trfName rhs
-        trfPatSynLhs id (RecordPatSyn flds) kw
+  where trfPatSynLhs :: Located (IdP n) -> HsPatSynDetails (Located (IdP n)) -> AnnKeywordId -> Trf (Ann AST.UPatSynLhs (Dom r) RangeStage)
+        trfPatSynLhs id (PrefixCon args) _
+          = annLocNoSema (pure $ foldLocs (getLoc id : map getLoc args)) $ AST.UNormalPatSyn <$> define (trfName @n id) <*> trfAnnList " " (trfName' @n) args
+        trfPatSynLhs op (InfixCon lhs rhs) _
+          = annLocNoSema (pure $ getLoc lhs `combineSrcSpans` getLoc rhs) $ AST.UInfixPatSyn <$> define (trfName @n lhs) <*> trfOperator @n op <*> trfName @n rhs
+        trfPatSynLhs id (RecCon flds) kw
           = annLocNoSema (mkSrcSpan (srcSpanStart (getLoc id)) <$> before kw)
-              $ AST.URecordPatSyn <$> define (trfName id) <*> trfAnnList ", " trfName' (map recordPatSynSelectorId flds)
+              $ AST.URecordPatSyn <$> define (trfName @n id) <*> trfAnnList ", " (trfName' @n) (map recordPatSynSelectorId flds)
 
         trfPatSynRhs :: HsPatSynDir n -> Located (Pat n) -> Trf (AST.UPatSynRhs (Dom r) RangeStage)
         trfPatSynRhs ImplicitBidirectional pat = AST.UBidirectionalPatSyn <$> trfPattern pat <*> nothing " where " "" atTheEnd
@@ -535,22 +543,22 @@
   KindSig k -> trfKindSig (Just k)
   TyVarSig _ -> convertionProblem "trfFamilyKind: TyVarSig not supported"
 
-trfFamilyResultSig :: TransformName n r => Located (FamilyResultSig n) -> Maybe (LInjectivityAnn n) -> Trf (AnnMaybeG AST.UTypeFamilySpec (Dom r) RangeStage)
+trfFamilyResultSig :: forall n r . TransformName n r => Located (FamilyResultSig n) -> Maybe (LInjectivityAnn n) -> Trf (AnnMaybeG AST.UTypeFamilySpec (Dom r) RangeStage)
 trfFamilyResultSig (L l fr) Nothing = case fr of
   NoSig -> nothing "" " " atTheEnd
   KindSig k -> makeJust <$> (annLocNoSema (pure l) $ AST.UTypeFamilyKind <$> trfKindSig' k)
   TyVarSig tv -> makeJust <$> (annLocNoSema (pure l) $ AST.UTypeFamilyTyVar <$> trfTyVar tv)
 trfFamilyResultSig (L _ sig) (Just (L l (InjectivityAnn n deps)))
-  = makeJust <$> (annLocNoSema (pure l) $ AST.UTypeFamilyInjectivity <$> (annContNoSema $ AST.UInjectivityAnn <$> tv <*> trfAnnList ", " trfName' deps))
+  = makeJust <$> (annLocNoSema (pure l) $ AST.UTypeFamilyInjectivity <$> (annContNoSema $ AST.UInjectivityAnn <$> tv <*> trfAnnList ", " (trfName' @n) deps))
     where tv = case sig of TyVarSig tv -> trfTyVar tv
-                           _ -> annLocNoSema (pure $ getLoc n) (AST.UTyVarDecl <$> trfName n <*> nothing "" "" (pure $ srcSpanEnd (getLoc n)))
+                           _ -> annLocNoSema (pure $ getLoc n) (AST.UTyVarDecl <$> trfName @n n <*> nothing "" "" (pure $ srcSpanEnd (getLoc n)))
 
-trfAnnotationSubject :: TransformName n r => SourceText -> AnnProvenance n -> SrcLoc -> Trf (Ann AST.UAnnotationSubject (Dom r) RangeStage)
+trfAnnotationSubject :: forall n r . TransformName n r => SourceText -> AnnProvenance (IdP n) -> SrcLoc -> Trf (Ann AST.UAnnotationSubject (Dom r) RangeStage)
 trfAnnotationSubject (fromSrcText -> stxt) subject payloadEnd
   = do payloadStart <- advanceStr stxt <$> atTheStart
-       case subject of ValueAnnProvenance name@(L l _) -> annLocNoSema (pure l) (AST.UNameAnnotation <$> trfName name)
+       case subject of ValueAnnProvenance name@(L l _) -> annLocNoSema (pure l) (AST.UNameAnnotation <$> trfName @n name)
                        TypeAnnProvenance name@(L l _) -> annLocNoSema (pure $ mkSrcSpan payloadStart (srcSpanEnd l))
-                                                                      (AST.UTypeAnnotation <$> trfName name)
+                                                                      (AST.UTypeAnnotation <$> trfName @n name)
                        ModuleAnnProvenance -> annLocNoSema (pure $ mkSrcSpan payloadStart payloadEnd) (pure AST.UModuleAnnotation)
 
 trfDataKeyword ::  NewOrData -> Trf (Ann AST.UDataOrNewtypeKeyword (Dom r) RangeStage)
@@ -597,17 +605,17 @@
             <*> trfExpr left
             <*> trfExpr right
 
-trfRuleBndr :: TransformName n r => Located (RuleBndr n) -> Trf (Ann AST.URuleVar (Dom r) RangeStage)
-trfRuleBndr = trfLocNoSema $ \case (RuleBndr n) -> AST.URuleVar <$> trfName n
-                                   (RuleBndrSig n k) -> AST.USigRuleVar <$> trfName n <*> trfType (hsib_body $ hswc_body k)
+trfRuleBndr :: forall n r . TransformName n r => Located (RuleBndr n) -> Trf (Ann AST.URuleVar (Dom r) RangeStage)
+trfRuleBndr = trfLocNoSema $ \case (RuleBndr n) -> AST.URuleVar <$> trfName @n n
+                                   (RuleBndrSig n k) -> AST.USigRuleVar <$> trfName @n n <*> trfType (hsib_body $ hswc_body k)
 
-trfMinimalFormula :: TransformName n r => Located (BooleanFormula (Located n)) -> Trf (Ann AST.UMinimalFormula (Dom r) RangeStage)
+trfMinimalFormula :: forall n r . TransformName n r => Located (BooleanFormula (Located (IdP n))) -> Trf (Ann AST.UMinimalFormula (Dom r) RangeStage)
 trfMinimalFormula = trfLocCorrect (pure mkNoSemanticInfo)
-                      (\sp -> if isGoodSrcSpan sp then pure sp else srcLocSpan <$> before AnnClose) trfMinimalFormula'
+                      (\sp -> if isGoodSrcSpan sp then pure sp else srcLocSpan <$> before AnnClose) (trfMinimalFormula' @n)
 
-trfMinimalFormula' :: TransformName n r => BooleanFormula (Located n) -> Trf (AST.UMinimalFormula (Dom r) RangeStage)
-trfMinimalFormula' (Var name) = AST.UMinimalName <$> trfName name
+trfMinimalFormula' :: forall n r . TransformName n r => BooleanFormula (Located (IdP n)) -> Trf (AST.UMinimalFormula (Dom r) RangeStage)
+trfMinimalFormula' (Var name) = AST.UMinimalName <$> trfName @n name
 trfMinimalFormula' (And formulas) -- empty Minimal pragma is mapped to an empty list
-  = AST.UMinimalAnd <$> makeListBefore " " " , " atTheEnd (mapM (trfLocNoSema trfMinimalFormula') formulas)
-trfMinimalFormula' (Or formulas) = AST.UMinimalOr <$> trfAnnList " | " trfMinimalFormula' formulas
-trfMinimalFormula' (Parens formula) = AST.UMinimalParen <$> trfMinimalFormula formula
+  = AST.UMinimalAnd <$> makeListBefore " " " , " atTheEnd (mapM (trfLocNoSema (trfMinimalFormula' @n)) formulas)
+trfMinimalFormula' (Or formulas) = AST.UMinimalOr <$> trfAnnList " | " (trfMinimalFormula' @n) formulas
+trfMinimalFormula' (Parens formula) = AST.UMinimalParen <$> (trfMinimalFormula @n) formula
diff --git a/Language/Haskell/Tools/BackendGHC/Exprs.hs b/Language/Haskell/Tools/BackendGHC/Exprs.hs
--- a/Language/Haskell/Tools/BackendGHC/Exprs.hs
+++ b/Language/Haskell/Tools/BackendGHC/Exprs.hs
@@ -1,4 +1,8 @@
-{-# LANGUAGE AllowAmbiguousTypes, LambdaCase, ScopedTypeVariables, TypeApplications, ViewPatterns #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the expression-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Exprs where
@@ -58,19 +62,19 @@
 createScopeInfo = do scope <- asks localsInScope
                      return (mkScopeInfo scope)
 
-trfExpr' :: TransformName n r => HsExpr n -> Trf (AST.UExpr (Dom r) RangeStage)
-trfExpr' (HsVar name) = AST.UVar <$> trfName name
+trfExpr' :: forall n r . TransformName n r => HsExpr n -> Trf (AST.UExpr (Dom r) RangeStage)
+trfExpr' (HsVar name) = AST.UVar <$> trfName @n name
 trfExpr' (HsUnboundVar name) = AST.UVar <$> trfNameText (occNameString $ unboundVarOcc name)
 trfExpr' (HsRecFld fld) = AST.UVar <$> (asks contRange >>= \l -> trfAmbiguousFieldName' l fld)
 trfExpr' (HsIPVar ip) = AST.UVar <$> trfImplicitName ip
 trfExpr' (HsOverLit (ol_val -> val)) = AST.ULit <$> annCont (asks contRange >>= pure . PreLiteralInfo) (trfOverloadedLit val)
 trfExpr' (HsLit val) = AST.ULit <$> annCont (pure $ RealLiteralInfo (monoLiteralType val)) (trfLiteral' val)
-trfExpr' (HsLam (unLoc . mg_alts -> [unLoc -> Match _ pats _ (GRHSs [unLoc -> GRHS [] expr] (unLoc -> EmptyLocalBinds))]))
+trfExpr' (HsLam (unLoc . mg_alts -> [unLoc -> Match _ pats (GRHSs [unLoc -> GRHS [] expr] (unLoc -> EmptyLocalBinds))]))
   = AST.ULambda <$> (makeNonemptyList " " $ mapM trfPattern pats) <*> addToScope pats (trfExpr expr)
 trfExpr' (HsLamCase (unLoc . mg_alts -> matches)) = AST.ULamCase <$> addToScope matches (trfAnnList " " trfAlt' matches)
 trfExpr' (HsApp e1 e2) = AST.UApp <$> trfExpr e1 <*> trfExpr e2
 trfExpr' (OpApp e1 (unLoc -> HsVar op) _ e2)
-  = AST.UInfixApp <$> trfExpr e1 <*> trfOperator op <*> trfExpr e2
+  = AST.UInfixApp <$> trfExpr e1 <*> trfOperator @n op <*> trfExpr e2
 trfExpr' (OpApp e1 (L nameLoc (HsRecFld fld)) _ e2)
   = AST.UInfixApp <$> trfExpr e1 <*> trfAmbiguousOperator' nameLoc fld <*> trfExpr e2
 trfExpr' (OpApp _ (L _ op) _ _) = unhandledElement "OpApp expression" op
@@ -78,11 +82,11 @@
                                        <*> trfExpr e
   where loc = mkSrcSpan <$> atTheStart <*> (pure $ srcSpanStart (getLoc e))
         info = createNameInfo =<< (fromMaybe (convProblem "minus operation is not found") <$> liftGhc negateOpName)
-        negateOpName = getFromNameUsing (\n -> (\case Just (AnId id) -> Just id; _ -> Nothing) <$> lookupName n) negateName
-trfExpr' (HsPar (unLoc -> SectionL expr (unLoc -> HsVar op))) = AST.ULeftSection <$> trfExpr expr <*> trfOperator op
+        negateOpName = getFromNameUsing @r (\n -> (\case Just (AnId id) -> Just id; _ -> Nothing) <$> lookupName n) negateName
+trfExpr' (HsPar (unLoc -> SectionL expr (unLoc -> HsVar op))) = AST.ULeftSection <$> trfExpr expr <*> trfOperator @n op
 trfExpr' (HsPar (unLoc -> SectionL expr (L nameLoc (HsRecFld op))))
   = AST.ULeftSection <$> trfExpr expr <*> trfAmbiguousOperator' nameLoc op
-trfExpr' (HsPar (unLoc -> SectionR (unLoc -> HsVar op) expr)) = AST.URightSection <$> trfOperator op <*> trfExpr expr
+trfExpr' (HsPar (unLoc -> SectionR (unLoc -> HsVar op) expr)) = AST.URightSection <$> trfOperator @n op <*> trfExpr expr
 trfExpr' (HsPar (unLoc -> SectionR (L nameLoc (HsRecFld op)) expr))
   = AST.URightSection <$> trfAmbiguousOperator' nameLoc op <*> trfExpr expr
 trfExpr' (HsPar expr) = AST.UParen <$> trfExpr expr
@@ -137,7 +141,7 @@
   = AST.UParArrayComp <$> trfExpr (getLastStmt stmts) <*> trfListCompStmts stmts
 trfExpr' (ExplicitList _ _ exprs) = AST.UList <$> trfAnnList' ", " trfExpr exprs
 trfExpr' (ExplicitPArr _ exprs) = AST.UParArray <$> trfAnnList' ", " trfExpr exprs
-trfExpr' (RecordCon name _ _ fields) = AST.URecCon <$> trfName name <*> trfFieldInits fields
+trfExpr' (RecordCon name _ _ fields) = AST.URecCon <$> trfName @n name <*> trfFieldInits fields
 trfExpr' (RecordUpd expr fields _ _ _ _) = AST.URecUpdate <$> trfExpr expr <*> trfAnnList ", " trfFieldUpdate fields
 trfExpr' (ExprWithTySig expr typ) = AST.UTypeSig <$> trfExpr expr <*> trfType (hsib_body $ hswc_body typ)
 trfExpr' (ArithSeq _ _ (From from)) = AST.UEnum <$> trfExpr from <*> nothing "," "" (before AnnDotdot)
@@ -191,10 +195,10 @@
                                                                     (AST.UFieldWildcard <$> (annCont (createImplicitFldInfo (unLoc . (\(HsVar n) -> n) . unLoc) (map unLoc implicitFlds)) (pure AST.FldWildcard)))
                                         else pure []))
 
-trfFieldInit :: TransformName n r => Located (HsRecField n (LHsExpr n)) -> Trf (Ann AST.UFieldUpdate (Dom r) RangeStage)
+trfFieldInit :: forall n r . TransformName n r => Located (HsRecField n (LHsExpr n)) -> Trf (Ann AST.UFieldUpdate (Dom r) RangeStage)
 trfFieldInit = trfLocNoSema $ \case
-  HsRecField id _ True -> AST.UFieldPun <$> trfName (getFieldOccName id)
-  HsRecField id val False -> AST.UNormalFieldUpdate <$> trfName (getFieldOccName id) <*> trfExpr val
+  HsRecField id _ True -> AST.UFieldPun <$> trfName @n (getFieldOccName id)
+  HsRecField id val False -> AST.UNormalFieldUpdate <$> trfName @n (getFieldOccName id) <*> trfExpr val
 
 trfFieldUpdate :: TransformName n r => HsRecField' (AmbiguousFieldOcc n) (LHsExpr n) -> Trf (AST.UFieldUpdate (Dom r) RangeStage)
 trfFieldUpdate (HsRecField id _ True) = AST.UFieldPun <$> trfAmbiguousFieldName id
@@ -207,7 +211,7 @@
 trfAlt' = gTrfAlt' trfExpr
 
 gTrfAlt' :: TransformName n r => (Located (ge n) -> Trf (Ann ae (Dom r) RangeStage)) -> Match n (Located (ge n)) -> Trf (AST.UAlt' ae (Dom r) RangeStage)
-gTrfAlt' te (Match _ [pat] _ (GRHSs rhss (unLoc -> locBinds)))
+gTrfAlt' te (Match _ [pat] (GRHSs rhss (unLoc -> locBinds)))
   = AST.UAlt <$> trfPattern pat <*> gTrfCaseRhss te rhss <*> trfWhereLocalBinds (collectLocs rhss) locBinds
 gTrfAlt' _ _ = convertionProblem "gTrfAlt': not exactly one alternative when transforming a case alternative"
 
@@ -245,7 +249,7 @@
                                                                        -- FIXME: needs a before
 trfCmd' (HsCmdArrForm expr _ _ cmds) = AST.UArrowFormCmd <$> trfExpr expr <*> makeList " " (before AnnClose) (mapM trfCmdTop cmds)
 trfCmd' (HsCmdApp cmd expr) = AST.UAppCmd <$> trfCmd cmd <*> trfExpr expr
-trfCmd' (HsCmdLam (MG (unLoc -> [unLoc -> Match _ pats _ (GRHSs [unLoc -> GRHS [] body] _)]) _ _ _))
+trfCmd' (HsCmdLam (MG (unLoc -> [unLoc -> Match _ pats (GRHSs [unLoc -> GRHS [] body] _)]) _ _ _))
   = AST.ULambdaCmd <$> (makeNonemptyList " " $ mapM trfPattern pats) <*> trfCmd body
 trfCmd' (HsCmdPar cmd) = AST.UParenCmd <$> trfCmd cmd
 trfCmd' (HsCmdCase expr (MG (unLoc -> alts) _ _ _))
diff --git a/Language/Haskell/Tools/BackendGHC/GHCUtils.hs b/Language/Haskell/Tools/BackendGHC/GHCUtils.hs
--- a/Language/Haskell/Tools/BackendGHC/GHCUtils.hs
+++ b/Language/Haskell/Tools/BackendGHC/GHCUtils.hs
@@ -1,4 +1,12 @@
-{-# LANGUAGE FlexibleContexts, FlexibleInstances, LambdaCase, RecordWildCards, ScopedTypeVariables #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 -- | Utility functions defined on the GHC AST representation.
 module Language.Haskell.Tools.BackendGHC.GHCUtils where
@@ -20,30 +28,28 @@
 import Type (TyThing(..), mkFunTys)
 
 class OutputableBndrId name => GHCName name where
-  rdrName :: name -> RdrName
-  getFromNameUsing :: Applicative f => (Name -> Ghc (f Id)) -> Name -> Ghc (f name)
+  rdrName :: IdP name -> RdrName
+  getFromNameUsing :: Applicative f => (Name -> Ghc (f Id)) -> Name -> Ghc (f (IdP name))
   getBindsAndSigs :: HsValBinds name -> ([LSig name], LHsBinds name)
-  nameFromId :: Id -> name
-  unpackPostRn :: RdrName -> PostRn name name -> name
-
-  gunpackPostRn :: a -> (name -> a) -> PostRn name name -> a
+  nameFromId :: Id -> IdP name
+  unpackPostRn :: RdrName -> PostRn name (IdP name) -> IdP name
+  gunpackPostRn :: a -> (IdP name -> a) -> PostRn name (IdP name) -> a
 
-instance GHCName RdrName where
+instance GHCName GhcPs where
   rdrName = id
   getFromNameUsing _ n = return $ pure (nameRdrName n)
   getBindsAndSigs (ValBindsIn binds sigs) = (sigs, binds)
   getBindsAndSigs _ = error "ValBindsOut: ValBindsOut in parsed source"
   nameFromId = nameRdrName . getName
   unpackPostRn rdr _ = rdr
-
   gunpackPostRn a _ _ = a
 
-occName :: GHCName n => n -> OccName
-occName = rdrNameOcc . rdrName
+occName :: forall n . GHCName n => IdP n -> OccName
+occName = rdrNameOcc . rdrName @n
 
-instance GHCName GHC.Name where
+instance GHCName GhcRn where
   rdrName = nameRdrName
-  getFromNameUsing f n = fmap nameFromId <$> f n
+  getFromNameUsing f n = fmap (nameFromId @GhcRn) <$> f n
   getBindsAndSigs (ValBindsOut bindGroups sigs) = (sigs, unionManyBags (map snd bindGroups))
   getBindsAndSigs _ = error "getBindsAndSigs: ValBindsIn in renamed source"
   nameFromId = getName
@@ -51,13 +57,11 @@
 
   gunpackPostRn _ f pr = f pr
 
-getFieldOccName :: GHCName n => Located (FieldOcc n) -> Located n
-getFieldOccName (L l (FieldOcc (L _ rdr) postRn)) = L l (unpackPostRn rdr postRn)
-
-getFieldOccName' :: GHCName n => FieldOcc n -> n
-getFieldOccName' (FieldOcc (L _ rdr) postRn) = unpackPostRn rdr postRn
-
+getFieldOccName :: forall n . GHCName n => Located (FieldOcc n) -> Located (IdP n)
+getFieldOccName (L l (FieldOcc (L _ rdr) postRn)) = L l ((unpackPostRn @n) rdr postRn)
 
+getFieldOccName' :: forall n . GHCName n => FieldOcc n -> IdP n
+getFieldOccName' (FieldOcc (L _ rdr) postRn) = (unpackPostRn @n) rdr postRn
 
 -- | Loading ids for top-level ghc names
 getTopLevelId :: GHC.Name -> Ghc (Maybe GHC.Id)
@@ -92,29 +96,32 @@
 instance HsHasName e => HsHasName (Located e) where
   hsGetNames p (L _ e) = hsGetNames p e
 
-instance HsHasName n => HsHasName (HsLocalBinds n) where
+instance HsHasName (IdP n) => HsHasName (HsLocalBinds n) where
   hsGetNames p (HsValBinds bnds) = hsGetNames p bnds
   hsGetNames _ _ = []
 
-instance (GHCName n, HsHasName n) => HsHasName (HsDecl n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (HsDecl n) where
   hsGetNames p (TyClD tycl) = hsGetNames p tycl
   hsGetNames p (ValD vald) = hsGetNames p vald
   hsGetNames p (ForD ford) = hsGetNames p ford
   hsGetNames p (InstD inst) = hsGetNames p inst
   hsGetNames _ _ = []
 
-instance (GHCName n, HsHasName n) => HsHasName (InstDecl n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (InstDecl n) where
   hsGetNames p (ClsInstD clsInst) = hsGetNames p (cid_datafam_insts clsInst)
   hsGetNames p (DataFamInstD dataFamInst) = hsGetNames p dataFamInst
   hsGetNames _ _ = []
 
-instance (GHCName n, HsHasName n) => HsHasName (DataFamInstDecl n) where
-  hsGetNames p dfid = hsGetNames p (dfid_defn dfid)
+instance (GHCName n, HsHasName (IdP n), HsHasName r) => HsHasName (FamEqn n p r) where
+  hsGetNames p (FamEqn id _ _ rhs) = hsGetNames p id ++ hsGetNames p rhs
 
-instance (GHCName n, HsHasName n) => HsHasName (TyClGroup n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (DataFamInstDecl n) where
+  hsGetNames p dfid = hsGetNames p (hsib_body $ dfid_eqn dfid)
+
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (TyClGroup n) where
   hsGetNames p (TyClGroup tycls _ _) = hsGetNames p tycls
 
-instance (GHCName n, HsHasName n) => HsHasName (TyClDecl n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (TyClDecl n) where
   hsGetNames p (FamDecl fd) = hsGetNames p fd
   hsGetNames p (SynDecl {tcdLName = name}) = hsGetNames p name
   hsGetNames p (DataDecl {tcdLName = name, tcdDataDefn = datadef})
@@ -123,13 +130,13 @@
     = let n = hsGetNames p name in n ++ hsGetNames (listToMaybe (map fst n)) sigs
                                      ++ hsGetNames (listToMaybe (map fst n)) typeAssocs
 
-instance (GHCName n, HsHasName n) => HsHasName (FamilyDecl n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (FamilyDecl n) where
  hsGetNames p (FamilyDecl { fdLName = name }) = hsGetNames p name
 
-instance (GHCName n, HsHasName n) => HsHasName (HsDataDefn n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (HsDataDefn n) where
   hsGetNames p (HsDataDefn {dd_cons = ctors}) = hsGetNames p ctors
 
-instance (GHCName n, HsHasName n) => HsHasName (ConDecl n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (ConDecl n) where
   hsGetNames p (ConDeclGADT {con_names = names, con_type = (HsIB _ (L _ (HsFunTy (L _ (HsRecTy flds)) _)) _)})
     = hsGetNames p names ++ hsGetNames p flds
   hsGetNames p (ConDeclGADT {con_names = names, con_type = (HsIB _ (L _ (HsRecTy flds)) _)})
@@ -138,60 +145,60 @@
   hsGetNames p (ConDeclH98 {con_name = name, con_details = details})
     = hsGetNames p name ++ hsGetNames p details
 
-instance (GHCName n, HsHasName n) => HsHasName (HsConDeclDetails n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (HsConDeclDetails n) where
   hsGetNames p (RecCon rec) = hsGetNames p rec
   hsGetNames _ _ = []
 
-instance (GHCName n, HsHasName n) => HsHasName (ConDeclField n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (ConDeclField n) where
   hsGetNames p (ConDeclField name _ _) = hsGetNames p name
 
-instance (GHCName n, HsHasName n) => HsHasName (FieldOcc n) where
-  hsGetNames p (FieldOcc _ pr) = gunpackPostRn [] (hsGetNames p :: n -> [(Name, Maybe Name)]) pr
+instance forall n . (GHCName n, HsHasName (IdP n)) => HsHasName (FieldOcc n) where
+  hsGetNames p (FieldOcc _ pr) = (gunpackPostRn @n) [] (hsGetNames p :: IdP n -> [(Name, Maybe Name)]) pr
 
-instance (GHCName n, HsHasName n) => HsHasName (Sig n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (Sig n) where
   hsGetNames p (TypeSig n _) = hsGetNames p n
   hsGetNames p (ClassOpSig _ n _) = hsGetNames p n
   hsGetNames p (PatSynSig n _) = hsGetNames p n
   hsGetNames _ _ = []
 
-instance HsHasName n => HsHasName (ForeignDecl n) where
+instance HsHasName (IdP n) => HsHasName (ForeignDecl n) where
   hsGetNames p (ForeignImport n _ _ _) = hsGetNames p n
   hsGetNames _ _ = []
 
-instance HsHasName n => HsHasName (HsValBinds n) where
+instance HsHasName (IdP n) => HsHasName (HsValBinds n) where
   hsGetNames p (ValBindsIn bnds _) = hsGetNames p bnds
   hsGetNames p (ValBindsOut bnds _) = hsGetNames p $ map snd bnds
 
 instance HsHasName n => HsHasName (Bag n) where
   hsGetNames p = hsGetNames p . bagToList
 
-instance HsHasName n => HsHasName (HsBind n) where
+instance HsHasName (IdP n) => HsHasName (HsBind n) where
   hsGetNames p (FunBind {fun_id = lname}) = hsGetNames p lname
   hsGetNames p (PatBind {pat_lhs = pat}) = hsGetNames p pat
   hsGetNames p (VarBind {var_id = id}) = hsGetNames p id
   hsGetNames p (PatSynBind (PSB {psb_id = id})) = hsGetNames p id
   hsGetNames _ _ = error "hsGetNames: called on compiler-generated binding"
 
-instance HsHasName n => HsHasName (ParStmtBlock l n) where
+instance HsHasName (IdP n) => HsHasName (ParStmtBlock l n) where
   hsGetNames p (ParStmtBlock _ binds _) = hsGetNames p binds
 
 --instance HsHasName n => HsHasName (LHsTyVarBndrs n) where
 --  hsGetNames (HsQTvs kvs tvs) = hsGetNames kvs ++ hsGetNames tvs
 
-instance HsHasName n => HsHasName (HsTyVarBndr n) where
+instance HsHasName (IdP n) => HsHasName (HsTyVarBndr n) where
   hsGetNames p (UserTyVar n) = hsGetNames p n
   hsGetNames p (KindedTyVar n _) = hsGetNames p n
 
-instance HsHasName n => HsHasName (Match n b) where
-  hsGetNames p (Match _ pats _ _) = concatMap (hsGetNames p) pats
+instance HsHasName (IdP n) => HsHasName (Match n b) where
+  hsGetNames p (Match _ pats _) = concatMap (hsGetNames p) pats
 
-instance HsHasName n => HsHasName (Stmt n b) where
+instance HsHasName (IdP n) => HsHasName (Stmt n b) where
   hsGetNames p (LetStmt binds) = hsGetNames p binds
   hsGetNames p (BindStmt pat _ _ _ _) = hsGetNames p pat
   hsGetNames p (RecStmt {recS_rec_ids = ids}) = hsGetNames p ids
   hsGetNames _ _ = []
 
-instance HsHasName n => HsHasName (Pat n) where
+instance HsHasName (IdP n) => HsHasName (Pat n) where
   hsGetNames x (VarPat id) = hsGetNames x id
   hsGetNames x (LazyPat p) = hsGetNames x p
   hsGetNames x (AsPat lname p) = hsGetNames x lname ++ hsGetNames x p
@@ -208,7 +215,7 @@
   hsGetNames x (SigPatOut p _) = hsGetNames x p
   hsGetNames _ _ = []
 
-instance (GHCName n, HsHasName n) => HsHasName (HsGroup n) where
+instance (GHCName n, HsHasName (IdP n)) => HsHasName (HsGroup n) where
   hsGetNames p g@(HsGroup vals _ clds _ _ _ foreigns _ _ _ _ _)
     = hsGetNames p vals ++ hsGetNames p clds ++ hsGetNames p (hsGroupInstDecls g) ++ hsGetNames p foreigns
 
@@ -221,21 +228,21 @@
   fromGHCName :: GHC.Name -> n
 
 instance FromGHCName RdrName where
-  fromGHCName = rdrName
+  fromGHCName = rdrName @GhcRn
 
 instance FromGHCName GHC.Name where
   fromGHCName = id
 
 -- | Tries to simplify the type that has HsAppsTy before renaming. Does not always provide the correct form.
 -- Treats each operator as if they are of equivalent precedence and always left-associative.
-cleanHsType :: forall n . (OutputableBndrId n) => HsType n -> HsType n
+cleanHsType :: forall n . (OutputableBndrId n, SourceTextX n) => HsType n -> HsType n
 -- for some reason * is considered infix
 cleanHsType (HsAppsTy apps) = unLoc $ guessType apps
   where guessType :: OutputableBndrId n => [LHsAppType n] -> LHsType n
         guessType (L l (HsAppInfix n) : rest) -- must be a prefix actually
           = guessType' (L l (HsTyVar NotPromoted n)) rest
         guessType (L _ (HsAppPrefix t) : rest) = guessType' t rest
-        guessType [] = error $ "guessType: empty: " ++ showSDocUnsafe (ppr apps)
+        guessType [] = error $ "guessType: empty" ++ showSDocUnsafe (ppr apps)
 
         guessType' :: LHsType n -> [LHsAppType n] -> LHsType n
         guessType' fun (L _ (HsAppPrefix t) : rest) = guessType' (hsAppTy fun t) rest
@@ -248,7 +255,7 @@
         hsAppTy :: LHsType n -> LHsType n -> LHsType n
         hsAppTy t1 t2 = L (getLoc t1 `combineSrcSpans` getLoc t2) $ HsAppTy t1 t2
 
-        hsOpTy :: LHsType n -> Located n -> LHsType n -> LHsType n
+        hsOpTy :: LHsType n -> Located (IdP n) -> LHsType n -> LHsType n
         hsOpTy t1 n t2 = L (getLoc t1 `combineSrcSpans` getLoc t2) $ HsOpTy t1 n t2
 cleanHsType t = t
 
diff --git a/Language/Haskell/Tools/BackendGHC/Kinds.hs b/Language/Haskell/Tools/BackendGHC/Kinds.hs
--- a/Language/Haskell/Tools/BackendGHC/Kinds.hs
+++ b/Language/Haskell/Tools/BackendGHC/Kinds.hs
@@ -1,4 +1,8 @@
-{-# LANGUAGE GADTs, ViewPatterns #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the kind-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Kinds where
@@ -29,9 +33,9 @@
 trfKind :: TransformName n r => Located (HsKind n) -> Trf (Ann AST.UKind (Dom r) RangeStage)
 trfKind = trfLocNoSema (trfKind' . cleanHsType)
 
-trfKind' ::TransformName n r => HsKind n -> Trf (AST.UKind (Dom r) RangeStage)
+trfKind' :: forall n r . TransformName n r => HsKind n -> Trf (AST.UKind (Dom r) RangeStage)
 trfKind' = trfKind'' . cleanHsType where
-  trfKind'' (HsTyVar _ (rdrName . unLoc -> Exact n))
+  trfKind'' (HsTyVar _ (rdrName @n . unLoc -> Exact n))
     | isWiredInName n && occNameString (nameOccName n) == "*"
     = pure AST.UStarKind
     | isWiredInName n && occNameString (nameOccName n) == "#"
@@ -39,22 +43,22 @@
   trfKind'' (HsParTy kind) = AST.UParenKind <$> trfKind kind
   trfKind'' (HsFunTy k1 k2) = AST.UFunKind <$> trfKind k1 <*> trfKind k2
   trfKind'' (HsAppTy k1 k2) = AST.UAppKind <$> trfKind k1 <*> trfKind k2
-  trfKind'' (HsOpTy k1 op k2) = AST.UInfixAppKind <$> trfKind k1 <*> trfOperator op <*> trfKind k2
-  trfKind'' (HsTyVar _ kv) = transformingPossibleVar kv (AST.UVarKind <$> trfName kv)
+  trfKind'' (HsOpTy k1 op k2) = AST.UInfixAppKind <$> trfKind k1 <*> trfOperator @n op <*> trfKind k2
+  trfKind'' (HsTyVar _ kv) = transformingPossibleVar kv (AST.UVarKind <$> trfName @n kv)
   trfKind'' (HsListTy kind) = AST.UListKind <$> trfKind kind
   trfKind'' (HsTupleTy _ kinds) = AST.UTupleKind <$> makeList ", " atTheStart (mapM trfKind kinds)
   trfKind'' (HsAppsTy [unLoc -> HsAppPrefix t]) = trfKind' (unLoc t)
-  trfKind'' (HsAppsTy [unLoc -> HsAppInfix n]) = AST.UVarKind <$> trfName n
+  trfKind'' (HsAppsTy [unLoc -> HsAppInfix n]) = AST.UVarKind <$> trfName @n n
   trfKind'' pt@(HsExplicitListTy {}) = AST.UPromotedKind <$> annContNoSema (trfPromoted' trfKind' pt)
   trfKind'' pt@(HsExplicitTupleTy {}) = AST.UPromotedKind <$> annContNoSema (trfPromoted' trfKind' pt)
   trfKind'' pt@(HsTyLit {}) = AST.UPromotedKind <$> annContNoSema (trfPromoted' trfKind' pt)
   trfKind'' t = AST.UTypeKind <$> annContNoSema (trfType' t)
 
-trfPromoted' :: (TransformName n r, HasNoSemanticInfo (Dom r) a)
+trfPromoted' :: forall n r a . (TransformName n r, HasNoSemanticInfo (Dom r) a)
                   => (HsType n -> Trf (a (Dom r) RangeStage)) -> HsType n -> Trf (AST.UPromoted a (Dom r) RangeStage)
 trfPromoted' _ (HsTyLit (HsNumTy _ int)) = pure $ AST.UPromotedInt int
 trfPromoted' _ (HsTyLit (HsStrTy _ str)) = pure $ AST.UPromotedString (unpackFS str)
-trfPromoted' _ (HsTyVar _ name) = AST.UPromotedCon <$> trfName name
+trfPromoted' _ (HsTyVar _ name) = AST.UPromotedCon <$> trfName @n name
 trfPromoted' f (HsExplicitListTy _ _ elems) = AST.UPromotedList <$> between AnnOpenS AnnCloseS (trfAnnList ", " f elems)
 trfPromoted' f (HsExplicitTupleTy _ elems) = AST.UPromotedTuple <$> between AnnOpenP AnnCloseP (trfAnnList ", " f elems)
 trfPromoted' _ t = unhandledElement "promoted type/kind" t
diff --git a/Language/Haskell/Tools/BackendGHC/Literals.hs b/Language/Haskell/Tools/BackendGHC/Literals.hs
--- a/Language/Haskell/Tools/BackendGHC/Literals.hs
+++ b/Language/Haskell/Tools/BackendGHC/Literals.hs
@@ -3,7 +3,7 @@
 
 import qualified Data.ByteString.Char8 as BS (foldr)
 
-import BasicTypes as GHC (FractionalLit(..))
+import BasicTypes as GHC (FractionalLit(..), IntegralLit(..))
 import FastString as GHC (unpackFS)
 import HsLit as GHC (OverLitVal(..), HsLit(..))
 import Type as GHC
@@ -14,8 +14,9 @@
 import qualified Language.Haskell.Tools.AST as AST (ULiteral(..))
 import Language.Haskell.Tools.BackendGHC.Monad (Trf)
 import Language.Haskell.Tools.BackendGHC.Utils
+import Language.Haskell.Tools.BackendGHC.Names
 
-trfLiteral' :: HsLit -> Trf (AST.ULiteral (Dom r) RangeStage)
+trfLiteral' :: TransformName n r => HsLit n -> Trf (AST.ULiteral (Dom r) RangeStage)
 trfLiteral' (HsChar _ ch) = pure $ AST.UCharLit ch
 trfLiteral' (HsCharPrim _ ch) = pure $ AST.UPrimCharLit ch
 trfLiteral' (HsString _ str) = pure $ AST.UStringLit (unpackFS str)
@@ -24,11 +25,11 @@
 trfLiteral' (HsWordPrim _ i) = pure $ AST.UPrimWordLit i
 trfLiteral' (HsInt64Prim _ i) = pure $ AST.UPrimIntLit i
 trfLiteral' (HsWord64Prim _ i) = pure $ AST.UPrimWordLit i
-trfLiteral' (HsFloatPrim frac) = pure $ AST.UPrimFloatLit (fl_value frac)
-trfLiteral' (HsDoublePrim frac) = pure $ AST.UPrimDoubleLit (fl_value frac)
+trfLiteral' (HsFloatPrim _ frac) = pure $ AST.UPrimFloatLit (fl_value frac)
+trfLiteral' (HsDoublePrim _ frac) = pure $ AST.UPrimDoubleLit (fl_value frac)
 trfLiteral' l = unhandledElement "literal" l
 
-monoLiteralType :: HsLit -> Type
+monoLiteralType :: HsLit n -> Type
 monoLiteralType (HsChar _ _) = charTy
 monoLiteralType (HsCharPrim _ _) = charPrimTy
 monoLiteralType (HsString _ _) = stringTy
@@ -37,10 +38,10 @@
 monoLiteralType (HsWordPrim _ _) = wordTy
 monoLiteralType (HsInt64Prim _ _) = int64PrimTy
 monoLiteralType (HsWord64Prim _ _) = word64PrimTy
-monoLiteralType (HsFloatPrim _) = floatX4PrimTy
-monoLiteralType (HsDoublePrim _) = doubleX2PrimTy
+monoLiteralType (HsFloatPrim _ _) = floatX4PrimTy
+monoLiteralType (HsDoublePrim _ _) = doubleX2PrimTy
 
 trfOverloadedLit :: OverLitVal -> Trf (AST.ULiteral (Dom r) RangeStage)
-trfOverloadedLit (HsIntegral _ i) = pure $ AST.UIntLit i
+trfOverloadedLit (HsIntegral (IL _ _ i)) = pure $ AST.UIntLit i
 trfOverloadedLit (HsFractional frac) = pure $ AST.UFracLit (fl_value frac)
 trfOverloadedLit (HsIsString _ str) = pure $ AST.UStringLit (unpackFS str)
diff --git a/Language/Haskell/Tools/BackendGHC/Modules.hs b/Language/Haskell/Tools/BackendGHC/Modules.hs
--- a/Language/Haskell/Tools/BackendGHC/Modules.hs
+++ b/Language/Haskell/Tools/BackendGHC/Modules.hs
@@ -1,4 +1,11 @@
-{-# LANGUAGE BangPatterns, FlexibleContexts, GADTs, LambdaCase, MultiWayIf, ScopedTypeVariables, TypeApplications, ViewPatterns #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiWayIf #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the module-related elements (modules, imports, exports) of the GHC AST to corresponding elements in the Haskell-tools AST representation
 -- Also contains the entry point of the transformation that collects the information from different GHC AST representations.
@@ -17,6 +24,7 @@
 import FastString as GHC (unpackFS)
 import FieldLabel as GHC (FieldLbl(..))
 import GHC
+import Avail
 import SrcLoc as GHC
 import TcRnMonad as GHC (Applicative(..), (<$>))
 
@@ -31,24 +39,25 @@
 import Language.Haskell.Tools.BackendGHC.Utils
 
 -- Transformes a module in its renamed state. This will be performed to help the transformation of the actual typed module representation.
-trfModule :: ModSummary -> Located (HsModule RdrName) -> Trf (Ann AST.UModule (Dom RdrName) RangeStage)
-trfModule mod hsMod = do -- createModuleInfo involves reading the ghc compiler state, so it must be evaluated
-                         -- or large parts of the representation will be kept
-                         !modInfo <- createModuleInfo mod (maybe noSrcSpan getLoc $ hsmodName $ unLoc hsMod) (hsmodImports $ unLoc hsMod)
-                         trfLocCorrect (pure modInfo)
-                            (\sr -> combineSrcSpans sr <$> (uniqueTokenAnywhere AnnEofPos))
-                            (\(HsModule name exports imports decls deprec _) ->
-                               AST.UModule <$> trfFilePragmas
-                                           <*> trfModuleHead name (srcSpanStart (foldLocs (map getLoc imports ++ map getLoc decls))) exports deprec
-                                           <*> trfImports imports
-                                           <*> trfDecls decls) $ hsMod
+trfModule :: ModSummary -> Located (HsModule GhcPs) -> Trf (Ann AST.UModule (Dom GhcPs) RangeStage)
+trfModule mod hsMod = do
+  -- createModuleInfo involves reading the ghc compiler state, so it must be evaluated
+  -- or large parts of the representation will be kept
+  !modInfo <- createModuleInfo mod (maybe noSrcSpan getLoc $ hsmodName $ unLoc hsMod) (hsmodImports $ unLoc hsMod)
+  trfLocCorrect (pure modInfo)
+     (\sr -> combineSrcSpans sr <$> (uniqueTokenAnywhere AnnEofPos))
+     (\(HsModule name exports imports decls deprec _) ->
+        AST.UModule <$> trfFilePragmas
+                    <*> trfModuleHead name (srcSpanStart (foldLocs (map getLoc imports ++ map getLoc decls))) exports deprec
+                    <*> trfImports imports
+                    <*> trfDecls decls) $ hsMod
 
 -- | Transformes the module in its typed state. Uses the results of 'trfModule' to extract program
 -- elements (splices for example) that are not kept in the typed representation.
-trfModuleRename :: ModSummary -> Ann AST.UModule (Dom RdrName) RangeStage
-                              -> (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString)
-                              -> Located (HsModule RdrName)
-                              -> Trf (Ann AST.UModule (Dom GHC.Name) RangeStage)
+trfModuleRename :: ModSummary -> Ann AST.UModule (Dom GhcPs) RangeStage
+                              -> RenamedSource
+                              -> Located (HsModule GhcPs)
+                              -> Trf (Ann AST.UModule (Dom GhcRn) RangeStage)
 trfModuleRename mod rangeMod (gr,imports,exps,_) hsMod
     = do -- createModuleInfo involves reading the ghc compiler state, so it must be evaluated
          -- or large parts of the representation will be kept
@@ -56,20 +65,22 @@
          trfLocCorrect (pure info) (\sr -> combineSrcSpans sr <$> (uniqueTokenAnywhere AnnEofPos)) (trfModuleRename' (info ^. implicitNames)) hsMod
   where roleAnnots = rangeMod ^? AST.modDecl&AST.annList&filtered ((\case Ann _ (AST.URoleDecl {}) -> True; _ -> False))
         originalNames = Map.fromList $ mapMaybe getSourceAndInfo (rangeMod ^? biplateRef)
-        getSourceAndInfo :: Ann AST.UQualifiedName (Dom RdrName) RangeStage -> Maybe (SrcSpan, RdrName)
+        getSourceAndInfo :: Ann AST.UQualifiedName (Dom GhcPs) RangeStage -> Maybe (SrcSpan, RdrName)
         getSourceAndInfo n = (,) <$> (n ^? annotation&sourceInfo&nodeSpan) <*> (n ^? semantics&nameInfo)
 
         exportDecls = rangeMod ^? AST.modHead & AST.annJust & AST.mhExports & AST.annJust & AST.espExports & AST.annList
         exportSubspecs = map (\e -> e ^? AST.exportDecl & AST.ieSubspec & AST.annJust & AST.essList & AST.annList) exportDecls
         exportSubspecsRngs = map (map AST.getRange) exportSubspecs
 
-        replaceSubspecLocs :: [LIE Name] -> [LIE Name]
+        replaceSubspecLocs :: [LIE GhcRn] -> [LIE GhcRn]
         replaceSubspecLocs exps = zipWith (\ss ie -> case ie of (L l (IEThingWith n wc ls flds)) -> L l (IEThingWith n wc (replaceNames ss ls) (replaceFieldNames (drop (length ls) ss) flds))
                                                                 _ -> ie) exportSubspecsRngs exps
           where replaceNames ss ls = zipWith (\(L _ iew) l -> case iew of IEName (L _ n) -> L l (IEName (L l n))
                                                                           _              -> L l iew) ls ss
                 replaceFieldNames ss ls = zipWith (\(L _ iew) l -> L l iew) ls ss
 
+        trfModuleRename' :: [PName GhcRn]
+                         -> HsModule GhcPs -> Trf (AST.UModule (Dom GhcRn) RangeStage)
         trfModuleRename' preludeImports hsMod@(HsModule name exports _ _ deprec _) = do
           transformedImports <- orderAnnList <$> (trfImports imports)
 
@@ -87,21 +98,23 @@
                  AST.UModule filePrags
                   <$> trfModuleHead name
                        (srcSpanEnd (AST.getRange filePrags))
-                       (case (exports, exps) of (Just (L l _), Just ie) -> Just (L l (replaceSubspecLocs (orderLocated ie)))
+                       (case (exports, exps) of (Just (L l _), Just ie) -> Just (L l (replaceSubspecLocs (orderLocated (map fst ie))))
                                                 _                       -> Nothing)
                        deprec
                   <*> return transformedImports
                   <*> trfDeclsGroup gr
 
 -- | Extract the template haskell splices from the representation and adds them to the transformation state.
-loadSplices :: HsModule RdrName -> Trf a -> Trf a
+loadSplices :: HsModule GhcPs -> Trf a -> Trf a
 loadSplices hsMod trf = do
-    let declSpls = map (\(SpliceDecl sp _) -> sp) $ hsMod ^? biplateRef :: [Located (HsSplice RdrName)]
-        exprSpls = mapMaybe (\case L l (HsSpliceE sp) -> Just (L l sp); _ -> Nothing) $ hsMod ^? biplateRef :: [Located (HsSplice RdrName)]
-        typeSpls = mapMaybe (\case L l (HsSpliceTy sp _) -> Just (L l sp); _ -> Nothing) $ hsMod ^? biplateRef :: [Located (HsSplice RdrName)]
+    let declSpls = map (\(SpliceDecl sp _) -> sp) $ hsMod ^? biplateRef :: [Located (HsSplice GhcPs)]
+        exprSpls = mapMaybe (\case L l (HsSpliceE sp) -> Just (L l sp); _ -> Nothing) $ hsMod ^? biplateRef :: [Located (HsSplice GhcPs)]
+        typeSpls = mapMaybe (\case L l (HsSpliceTy sp _) -> Just (L l sp); _ -> Nothing) $ hsMod ^? biplateRef :: [Located (HsSplice GhcPs)]
     setSplices declSpls typeSpls exprSpls trf
 
-trfModuleHead :: TransformName n r => Maybe (Located ModuleName) -> SrcLoc -> Maybe (Located [LIE n]) -> Maybe (Located WarningTxt) -> Trf (AnnMaybeG AST.UModuleHead (Dom r) RangeStage)
+trfModuleHead :: TransformName n r
+              => Maybe (Located ModuleName) -> SrcLoc -> Maybe (Located [LIE n])
+                   -> Maybe (Located WarningTxt) -> Trf (AnnMaybeG AST.UModuleHead (Dom r) RangeStage)
 trfModuleHead (Just mn) _ exports modPrag
   = makeJust <$> (annLocNoSema (tokensLoc [AnnModule, AnnWhere])
                                (AST.UModuleHead <$> trfModuleName mn
@@ -191,16 +204,16 @@
 trfIESpec :: TransformName n r => LIE n -> Trf (Maybe (Ann AST.UIESpec (Dom r) RangeStage))
 trfIESpec = trfMaybeLocNoSema trfIESpec'
 
-trfIESpec' :: TransformName n r => IE n -> Trf (Maybe (AST.UIESpec (Dom r) RangeStage))
-trfIESpec' (IEVar n) = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName (getWrappedName n) <*> (nothing "(" ")" atTheEnd))
-trfIESpec' (IEThingAbs n) = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName (getWrappedName n) <*> (nothing "(" ")" atTheEnd))
+trfIESpec' :: forall n r . TransformName n r => IE n -> Trf (Maybe (AST.UIESpec (Dom r) RangeStage))
+trfIESpec' (IEVar n) = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName @n (getWrappedName n) <*> (nothing "(" ")" atTheEnd))
+trfIESpec' (IEThingAbs n) = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName @n (getWrappedName n) <*> (nothing "(" ")" atTheEnd))
 trfIESpec' (IEThingAll n)
-  = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName (getWrappedName n) <*> (makeJust <$> subspec))
+  = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName @n (getWrappedName n) <*> (makeJust <$> subspec))
   where subspec = annLocNoSema (combineSrcSpans <$> tokenLocBack AnnOpenP <*> tokenLocBack AnnCloseP) (pure AST.USubSpecAll)
 trfIESpec' (IEThingWith n _ ls flds)
-  = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName (getWrappedName n) <*> (makeJust <$> subspec))
+  = Just <$> (AST.UIESpec <$> trfImportModifier <*> trfName @n (getWrappedName n) <*> (makeJust <$> subspec))
   where subspec = annLocNoSema (combineSrcSpans <$> tokenLocBack AnnOpenP <*> tokenLocBack AnnCloseP)
-                    $ AST.USubSpecList <$> between AnnOpenP AnnCloseP (makeList ", " atTheStart ((++) <$> mapM (trfName . getWrappedName) ls <*> mapM trfName (map (fmap flSelector) flds)))
+                    $ AST.USubSpecList <$> between AnnOpenP AnnCloseP (makeList ", " atTheStart ((++) <$> mapM ((trfName @n) . getWrappedName) ls <*> mapM (trfName @n) (map (fmap flSelector) flds)))
 trfIESpec' _ = pure Nothing
 
 getWrappedName :: Located (IEWrappedName n) -> Located n
diff --git a/Language/Haskell/Tools/BackendGHC/Monad.hs b/Language/Haskell/Tools/BackendGHC/Monad.hs
--- a/Language/Haskell/Tools/BackendGHC/Monad.hs
+++ b/Language/Haskell/Tools/BackendGHC/Monad.hs
@@ -28,7 +28,7 @@
 import OccName as GHC (HasOccName(..), mkOccEnv)
 import Outputable hiding (empty)
 import RdrName
-import RnEnv (mkUnboundNameRdr)
+import RnUnbound (mkUnboundNameRdr)
 import RnExpr (rnLExpr)
 import TcRnMonad
 import TcRnTypes (TcGblEnv(..))
@@ -40,16 +40,16 @@
 data TrfInput
   = TrfInput { srcMap :: SourceMap -- ^ The lexical tokens of the source file
              , pragmaComms :: Map String [Located String] -- ^ Pragma comments
-             , declsToInsert :: [Ann UDecl (Dom RdrName) RangeStage] -- ^ Declarations that are from the parsed AST
+             , declsToInsert :: [Ann UDecl (Dom GhcPs) RangeStage] -- ^ Declarations that are from the parsed AST
              , contRange :: SrcSpan -- ^ The focus of the transformation
              , localsInScope :: [[(GHC.Name, Maybe [UsageSpec], Maybe Name)]] -- ^ Local names visible
              , defining :: Bool -- ^ True, if names are defined in the transformed AST element.
              , definingTypeVars :: Bool -- ^ True, if type variable names are defined in the transformed AST element.
              , originalNames :: Map SrcSpan RdrName -- ^ Stores the original format of names.
-             , declSplices :: [Located (HsSplice GHC.RdrName)] -- ^ Location of the TH splices for extracting declarations from the renamed AST.
+             , declSplices :: [Located (HsSplice GhcPs)] -- ^ Location of the TH splices for extracting declarations from the renamed AST.
                  -- ^ It is possible that multiple declarations stand in the place of the declaration splice or none at all.
-             , typeSplices :: [Located (HsSplice GHC.RdrName)] -- ^ Type splices
-             , exprSplices :: [Located (HsSplice GHC.RdrName)] -- ^ Expression splices
+             , typeSplices :: [Located (HsSplice GhcPs)] -- ^ Type splices
+             , exprSplices :: [Located (HsSplice GhcPs)] -- ^ Expression splices
              }
 
 trfInit :: Map ApiAnnKey [SrcSpan] -> Map String [Located String] -> TrfInput
@@ -93,7 +93,7 @@
 addEmptyScope = local (\s -> s { localsInScope = [] : localsInScope s })
 
 -- | Perform the transformation putting the given definition in a new local scope.
-addToScopeImported :: [(String, Maybe String, Bool, [PName GHC.Name])] -> Trf a -> Trf a
+addToScopeImported :: [(String, Maybe String, Bool, [PName GhcRn])] -> Trf a -> Trf a
 addToScopeImported ls = local (\s -> s { localsInScope = concatMap (\(mn, asName, q, e) -> map (\(PName n p) -> (n, Just [UsageSpec q mn (fromMaybe mn asName)], p)) e) ls : localsInScope s })
 
 
@@ -119,12 +119,12 @@
                        asks (rdrNameStr . fromMaybe n . (Map.lookup sp) . originalNames)
 
 -- | Set splices that must replace the elements that are generated into the AST representation.
-setSplices :: [Located (HsSplice GHC.RdrName)] -> [Located (HsSplice GHC.RdrName)] -> [Located (HsSplice GHC.RdrName)] -> Trf a -> Trf a
+setSplices :: [Located (HsSplice GhcPs)] -> [Located (HsSplice GhcPs)] -> [Located (HsSplice GhcPs)] -> Trf a -> Trf a
 setSplices declSpls typeSpls exprSpls
   = local (\s -> s { typeSplices = typeSpls, exprSplices = exprSpls, declSplices = declSpls })
 
 -- | Set the list of declarations that will be missing from AST
-setDeclsToInsert :: [Ann UDecl (Dom RdrName) RangeStage] -> Trf a -> Trf a
+setDeclsToInsert :: [Ann UDecl (Dom GhcPs) RangeStage] -> Trf a -> Trf a
 setDeclsToInsert decls = local (\s -> s {declsToInsert = decls})
 
 -- Remove the splice that has already been added
@@ -135,7 +135,7 @@
 typeSpliceInserted :: Located (HsSplice n) -> Trf a -> Trf a
 typeSpliceInserted spl = local (\s -> s { typeSplices = Prelude.filter (\sp -> getLoc sp /= getLoc spl) (typeSplices s) })
 
-rdrSplice :: HsSplice RdrName -> Trf (HsSplice GHC.Name)
+rdrSplice :: HsSplice GhcPs -> Trf (HsSplice GhcRn)
 rdrSplice spl = do
     rng <- asks contRange
     env <- liftGhc getSession
diff --git a/Language/Haskell/Tools/BackendGHC/Names.hs b/Language/Haskell/Tools/BackendGHC/Names.hs
--- a/Language/Haskell/Tools/BackendGHC/Names.hs
+++ b/Language/Haskell/Tools/BackendGHC/Names.hs
@@ -1,4 +1,11 @@
-{-# LANGUAGE AllowAmbiguousTypes, FlexibleContexts, FlexibleInstances, GADTs, MultiParamTypeClasses, ScopedTypeVariables, TypeApplications, UndecidableInstances #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 -- | Functions that convert the basic elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Names where
@@ -14,6 +21,7 @@
 import OccName as GHC (HasOccName)
 import RdrName as GHC (RdrName)
 import SrcLoc as GHC
+import qualified Id  as GHC (Id)
 
 import Language.Haskell.Tools.AST (Ann(..), AnnListG, RangeStage, Dom)
 import qualified Language.Haskell.Tools.AST as AST
@@ -22,66 +30,66 @@
 import Language.Haskell.Tools.BackendGHC.Monad
 import Language.Haskell.Tools.BackendGHC.Utils
 
-trfOperator :: TransformName n r => Located n -> Trf (Ann AST.UOperator (Dom r) RangeStage)
-trfOperator = trfLocNoSema trfOperator'
+trfOperator :: forall n r . TransformName n r => Located (IdP n) -> Trf (Ann AST.UOperator (Dom r) RangeStage)
+trfOperator = trfLocNoSema (trfOperator' @n)
 
-trfOperator' :: TransformName n r => n -> Trf (AST.UOperator (Dom r) RangeStage)
+trfOperator' :: forall n r . TransformName n r => IdP n -> Trf (AST.UOperator (Dom r) RangeStage)
 trfOperator' n
-  | isSymOcc (occName n) = AST.UNormalOp <$> trfQualifiedNameFocus True n
-  | otherwise = AST.UBacktickOp <$> trfQualifiedNameFocus True n
+  | isSymOcc (occName @n n) = AST.UNormalOp <$> (trfQualifiedNameFocus @n) True n
+  | otherwise = AST.UBacktickOp <$> (trfQualifiedNameFocus @n) True n
 
-trfName :: TransformName n r => Located n -> Trf (Ann AST.UName (Dom r) RangeStage)
-trfName = trfLocNoSema trfName'
+trfName :: forall n r . TransformName n r => Located (IdP n) -> Trf (Ann AST.UName (Dom r) RangeStage)
+trfName = trfLocNoSema (trfName' @n)
 
-trfName' :: TransformName n r => n -> Trf (AST.UName (Dom r) RangeStage)
+trfName' :: forall n r . TransformName n r => IdP n -> Trf (AST.UName (Dom r) RangeStage)
 trfName' n
-  | isSymOcc (occName n) = (if isSpecKind then AST.UNormalName else AST.UParenName) <$> trfQualifiedNameFocus isSpecKind n
-  | otherwise = AST.UNormalName <$> trfQualifiedNameFocus False n
+  | isSymOcc (occName @n n) = (if isSpecKind then AST.UNormalName else AST.UParenName) <$> (trfQualifiedNameFocus @n) isSpecKind n
+  | otherwise = AST.UNormalName <$> (trfQualifiedNameFocus @n) False n
   where -- special names that are operators, but appear in name context
-    isSpecKind = occNameString (occName n) `elem` ["*", "#", "?", "??"]
+    isSpecKind = occNameString (occName @n n) `elem` ["*", "#", "?", "??"]
 
 trfAmbiguousFieldName :: TransformName n r => Located (AmbiguousFieldOcc n) -> Trf (Ann AST.UName (Dom r) RangeStage)
 trfAmbiguousFieldName (L l af) = trfAmbiguousFieldName' l af
 
 trfAmbiguousFieldName' :: forall n r . TransformName n r => SrcSpan -> AmbiguousFieldOcc n -> Trf (Ann AST.UName (Dom r) RangeStage)
-trfAmbiguousFieldName' l (Unambiguous (L _ rdr) pr) = annLocNoSema (pure l) $ trfName' (unpackPostRn @n rdr pr)
+trfAmbiguousFieldName' l (Unambiguous (L _ rdr) pr) = annLocNoSema (pure l) $ trfName' @n (unpackPostRn @n rdr pr)
 -- no Id transformation is done, so we can basically ignore the postTC value
 trfAmbiguousFieldName' _ (Ambiguous (L l rdr) _)
   = annLocNoSema (pure l)
-      $ (if (isSymOcc (occName rdr)) then AST.UParenName else AST.UNormalName)
-          <$> (annLoc (createAmbigousNameInfo rdr l) (pure l) $ AST.nameFromList <$> trfNameStr (isSymOcc (occName rdr)) (rdrNameStr rdr))
+      $ (if (isSymOcc (occName @GhcPs rdr)) then AST.UParenName else AST.UNormalName)
+          <$> (annLoc (createAmbigousNameInfo rdr l) (pure l) $ AST.nameFromList <$> trfNameStr (isSymOcc (occName @GhcPs rdr)) (rdrNameStr rdr))
 
 trfAmbiguousOperator' :: forall n r . TransformName n r => SrcSpan -> AmbiguousFieldOcc n -> Trf (Ann AST.UOperator (Dom r) RangeStage)
-trfAmbiguousOperator' l (Unambiguous (L _ rdr) pr) = annLocNoSema (pure l) $ trfOperator' (unpackPostRn @n rdr pr)
+trfAmbiguousOperator' l (Unambiguous (L _ rdr) pr) = annLocNoSema (pure l) $ trfOperator' @n (unpackPostRn @n rdr pr)
 -- no Id transformation is done, so we can basically ignore the postTC value
 trfAmbiguousOperator' _ (Ambiguous (L l rdr) _)
   = annLocNoSema (pure l)
-      $ (if (isSymOcc (occName rdr)) then AST.UNormalOp else AST.UBacktickOp)
-          <$> (annLoc (createAmbigousNameInfo rdr l) (pure l) $ AST.nameFromList <$> trfOperatorStr (not $ isSymOcc (occName rdr)) (rdrNameStr rdr))
+      $ (if (isSymOcc (occName @GhcPs rdr)) then AST.UNormalOp else AST.UBacktickOp)
+          <$> (annLoc (createAmbigousNameInfo rdr l) (pure l) $ AST.nameFromList <$> trfOperatorStr (not $ isSymOcc (occName @GhcPs rdr)) (rdrNameStr rdr))
 
-class (DataId n, Eq n, GHCName n, FromGHCName n, NameOrRdrName n ~ n, HasOccName n) => TransformableName n where
-  correctNameString :: n -> Trf String
-  transformSplice :: HsSplice RdrName -> Trf (HsSplice n)
+class (DataId n, Eq n, GHCName n, FromGHCName (IdP n), NameOrRdrName (IdP n) ~ IdP n, HasOccName (IdP n), SourceTextX n)
+        => TransformableName n where
+  correctNameString :: IdP n -> Trf String
+  transformSplice :: HsSplice GhcPs -> Trf (HsSplice n)
 
-instance TransformableName RdrName where
+instance TransformableName GhcPs where
   correctNameString = pure . rdrNameStr
   transformSplice = pure
 
-instance TransformableName GHC.Name where
-  correctNameString n = getOriginalName (rdrName n)
+instance TransformableName GhcRn where
+  correctNameString n = getOriginalName (rdrName @GhcRn n)
   transformSplice = rdrSplice
 
 -- | This class allows us to use the same transformation code for multiple variants of the GHC AST.
 -- GHC UName annotated with 'name' can be transformed to our representation with semantic annotations of 'res'.
-class (TransformableName name, HsHasName name, TransformableName res, HsHasName res, GHCName res)
+class (TransformableName name, HsHasName (IdP name), FromGHCName (IdP res), Eq (IdP name) {-, TransformableName res, HsHasName res -}, GHCName res, NameOrRdrName (IdP name) ~ (IdP name))
         => TransformName name res where
   -- | Demote a given name
-  transformName :: name -> res
+  transformName :: IdP name -> IdP res
 
-instance {-# OVERLAPPABLE #-} (n ~ r, TransformableName n, HsHasName n) => TransformName n r where
-  transformName = id
+instance TransformName GhcPs GhcPs where transformName = id
 
-instance {-# OVERLAPS #-} (TransformableName res, GHCName res, HsHasName res) => TransformName GHC.Name res where
+instance {-# OVERLAPPABLE #-} (FromGHCName (IdP res), GHCName res) => TransformName GhcRn res where
   transformName = fromGHCName
 
 trfNameText :: String -> Trf (Ann AST.UName (Dom r) RangeStage)
@@ -99,18 +107,18 @@
 isOperatorStr :: String -> Bool
 isOperatorStr = any (not . isAlphaNum)
 
-trfQualifiedName :: TransformName n r => Bool -> Located n -> Trf (Ann AST.UQualifiedName (Dom r) RangeStage)
-trfQualifiedName isOperator (L l n) = focusOn l $ trfQualifiedNameFocus isOperator n
+trfQualifiedName :: forall n r . TransformName n r => Bool -> Located (IdP n) -> Trf (Ann AST.UQualifiedName (Dom r) RangeStage)
+trfQualifiedName isOperator (L l n) = focusOn l $ (trfQualifiedNameFocus @n) isOperator n
 
-trfQualifiedNameFocus :: TransformName n r => Bool -> n -> Trf (Ann AST.UQualifiedName (Dom r) RangeStage)
+trfQualifiedNameFocus :: forall n r . TransformName n r => Bool -> IdP n -> Trf (Ann AST.UQualifiedName (Dom r) RangeStage)
 trfQualifiedNameFocus isOperator n
   = do rng <- asks contRange
-       let rng' = if isOperator == isSymOcc (occName n) then rng
+       let rng' = if isOperator == isSymOcc (occName @n n) then rng
                     else mkSrcSpan (updateCol (+1) (srcSpanStart rng)) (updateCol (subtract 1) (srcSpanEnd rng))
-       annLoc (createNameInfo (transformName n)) (pure rng') (trfQualifiedName' n)
+       annLoc (createNameInfo (transformName @n @r n)) (pure rng') (trfQualifiedName' @n n)
 
-trfQualifiedName' :: TransformName n r => n -> Trf (AST.UQualifiedName (Dom r) RangeStage)
-trfQualifiedName' n = AST.nameFromList <$> ((if isSymOcc (occName n) then trfOperatorStr else trfNameStr) False =<< correctNameString n)
+trfQualifiedName' :: forall n r . TransformName n r => IdP n -> Trf (AST.UQualifiedName (Dom r) RangeStage)
+trfQualifiedName' n = AST.nameFromList <$> ((if isSymOcc (occName @n n) then trfOperatorStr else trfNameStr) False =<< (correctNameString @n) n)
 
 trfOperatorStr :: Bool -> String -> Trf (AnnListG AST.UNamePart (Dom r) RangeStage)
 trfOperatorStr isInParen str = do rng <- correctSpan <$> asks contRange
diff --git a/Language/Haskell/Tools/BackendGHC/Patterns.hs b/Language/Haskell/Tools/BackendGHC/Patterns.hs
--- a/Language/Haskell/Tools/BackendGHC/Patterns.hs
+++ b/Language/Haskell/Tools/BackendGHC/Patterns.hs
@@ -1,4 +1,7 @@
-{-# LANGUAGE AllowAmbiguousTypes, ScopedTypeVariables, ViewPatterns #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the pattern-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Patterns where
@@ -26,14 +29,14 @@
 import Language.Haskell.Tools.AST (Ann, Dom, RangeStage)
 import qualified Language.Haskell.Tools.AST as AST
 
-trfPattern :: TransformName n r => Located (Pat n) -> Trf (Ann AST.UPattern (Dom r) RangeStage)
+trfPattern :: forall n r . TransformName n r => Located (Pat n) -> Trf (Ann AST.UPattern (Dom r) RangeStage)
 -- field wildcards are not directly represented in GHC AST
 trfPattern (L l (ConPatIn name (RecCon (HsRecFields flds _)))) | any ((l ==) . getLoc) flds
   = focusOn l $ do
       let (fromWC, notWC) = partition ((l ==) . getLoc) flds
       normalFields <- mapM (trfLocNoSema trfPatternField') notWC
       wildc <- annLocNoSema (tokenLocBack AnnDotdot) (AST.UFieldWildcardPattern <$> annCont (createImplicitFldInfo (unLoc . (\(VarPat n) -> n) . unLoc) (map unLoc fromWC)) (pure AST.FldWildcard))
-      annLocNoSema (pure l) (AST.URecPat <$> trfName name <*> makeNonemptyList ", " (pure (normalFields ++ [wildc])))
+      annLocNoSema (pure l) (AST.URecPat <$> trfName @n name <*> makeNonemptyList ", " (pure (normalFields ++ [wildc])))
 trfPattern p = trfLocNoSema trfPattern' (correctPatternLoc p)
 
 -- | Locations for right-associative infix patterns are incorrect in GHC AST
@@ -42,27 +45,27 @@
   = L (getLoc (correctPatternLoc left) `combineSrcSpans` getLoc (correctPatternLoc right)) p
 correctPatternLoc p = p
 
-trfPattern' :: TransformName n r => Pat n -> Trf (AST.UPattern (Dom r) RangeStage)
+trfPattern' :: forall n r . TransformName n r => Pat n -> Trf (AST.UPattern (Dom r) RangeStage)
 trfPattern' (WildPat _) = pure AST.UWildPat
-trfPattern' (VarPat name) = define $ AST.UVarPat <$> trfName name
+trfPattern' (VarPat name) = define $ AST.UVarPat <$> trfName @n name
 trfPattern' (LazyPat pat) = AST.UIrrefutablePat <$> trfPattern pat
-trfPattern' (AsPat name pat) = AST.UAsPat <$> define (trfName name) <*> trfPattern pat
+trfPattern' (AsPat name pat) = AST.UAsPat <$> define (trfName @n name) <*> trfPattern pat
 trfPattern' (ParPat pat) = AST.UParenPat <$> trfPattern pat
 trfPattern' (BangPat pat) = AST.UBangPat <$> trfPattern pat
 trfPattern' (ListPat pats _ _) = AST.UListPat <$> makeList ", " atTheEnd (mapM trfPattern pats)
 trfPattern' (TuplePat pats Boxed _) = AST.UTuplePat <$> makeList ", " atTheEnd (mapM trfPattern pats)
 trfPattern' (TuplePat pats Unboxed _) = AST.UUnboxTuplePat <$> makeList ", " atTheEnd (mapM trfPattern pats)
 trfPattern' (PArrPat pats _) = AST.UParArrPat <$> makeList ", " atTheEnd (mapM trfPattern pats)
-trfPattern' (ConPatIn name (PrefixCon args)) = AST.UAppPat <$> trfName name <*> makeList " " atTheEnd (mapM trfPattern args)
-trfPattern' (ConPatIn name (RecCon (HsRecFields flds _))) = AST.URecPat <$> trfName name <*> trfAnnList ", " trfPatternField' flds
-trfPattern' (ConPatIn name (InfixCon left right)) = AST.UInfixAppPat <$> trfPattern left <*> trfOperator name <*> trfPattern right
+trfPattern' (ConPatIn name (PrefixCon args)) = AST.UAppPat <$> trfName @n name <*> makeList " " atTheEnd (mapM trfPattern args)
+trfPattern' (ConPatIn name (RecCon (HsRecFields flds _))) = AST.URecPat <$> trfName @n name <*> trfAnnList ", " trfPatternField' flds
+trfPattern' (ConPatIn name (InfixCon left right)) = AST.UInfixAppPat <$> trfPattern left <*> trfOperator @n name <*> trfPattern right
 trfPattern' (ViewPat expr pat _) = AST.UViewPat <$> trfExpr expr <*> trfPattern pat
 trfPattern' (SplicePat qq@(HsQuasiQuote {})) = AST.UQuasiQuotePat <$> annContNoSema (trfQuasiQuotation' qq)
 trfPattern' (SplicePat splice) = AST.USplicePat <$> trfSplice splice
 trfPattern' (LitPat lit) = AST.ULitPat <$> annCont (pure $ RealLiteralInfo (monoLiteralType lit)) (trfLiteral' lit)
 trfPattern' (SigPatIn pat (hsib_body . hswc_body -> typ)) = AST.UTypeSigPat <$> trfPattern pat <*> trfType typ
 trfPattern' (NPat (ol_val . unLoc -> lit) _ _ _) = AST.ULitPat <$> annCont (asks contRange >>= pure . PreLiteralInfo) (trfOverloadedLit lit)
-trfPattern' (NPlusKPat id (L l lit) _ _ _ _) = AST.UNPlusKPat <$> define (trfName id) <*> annLoc (asks contRange >>= pure . PreLiteralInfo) (pure l) (trfOverloadedLit (ol_val lit))
+trfPattern' (NPlusKPat id (L l lit) _ _ _ _) = AST.UNPlusKPat <$> define (trfName @n id) <*> annLoc (asks contRange >>= pure . PreLiteralInfo) (pure l) (trfOverloadedLit (ol_val lit))
 trfPattern' (CoPat _ pat _) = trfPattern' pat -- coercion pattern introduced by GHC
 trfPattern' (SumPat pat tag arity _)
   = do sepsBefore <- focusBeforeLoc (srcSpanStart (getLoc pat)) (eachTokenLoc (AnnOpen : replicate (tag - 1) AnnVbar))
@@ -75,6 +78,6 @@
   where makePlaceholder l = annLocNoSema (pure (srcLocSpan l)) (pure AST.UUnboxedSumPlaceHolder)
 trfPattern' p = unhandledElement "pattern" p
 
-trfPatternField' :: TransformName n r => HsRecField n (LPat n) -> Trf (AST.UPatternField (Dom r) RangeStage)
-trfPatternField' (HsRecField id arg False) = AST.UNormalFieldPattern <$> trfName (getFieldOccName id) <*> trfPattern arg
-trfPatternField' (HsRecField id _ True) = AST.UFieldPunPattern <$> trfName (getFieldOccName id)
+trfPatternField' :: forall n r . TransformName n r => HsRecField n (LPat n) -> Trf (AST.UPatternField (Dom r) RangeStage)
+trfPatternField' (HsRecField id arg False) = AST.UNormalFieldPattern <$> trfName @n (getFieldOccName id) <*> trfPattern arg
+trfPatternField' (HsRecField id _ True) = AST.UFieldPunPattern <$> trfName @n (getFieldOccName id)
diff --git a/Language/Haskell/Tools/BackendGHC/Stmts.hs b/Language/Haskell/Tools/BackendGHC/Stmts.hs
--- a/Language/Haskell/Tools/BackendGHC/Stmts.hs
+++ b/Language/Haskell/Tools/BackendGHC/Stmts.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE GADTs, LambdaCase, ViewPatterns #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the statement-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Stmts where
diff --git a/Language/Haskell/Tools/BackendGHC/TH.hs b/Language/Haskell/Tools/BackendGHC/TH.hs
--- a/Language/Haskell/Tools/BackendGHC/TH.hs
+++ b/Language/Haskell/Tools/BackendGHC/TH.hs
@@ -1,4 +1,4 @@
-
+{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}
 -- | Functions that convert the Template-Haskell-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.TH where
 
@@ -20,10 +20,10 @@
 import Language.Haskell.Tools.AST (Ann, Dom, RangeStage)
 import qualified Language.Haskell.Tools.AST as AST
 
-trfQuasiQuotation' :: TransformName n r => HsSplice n -> Trf (AST.UQuasiQuote (Dom r) RangeStage)
+trfQuasiQuotation' :: forall n r . TransformName n r => HsSplice n -> Trf (AST.UQuasiQuote (Dom r) RangeStage)
  -- the lexer does not provide us with tokens '[', '|' and '|]'
 trfQuasiQuotation' (HsQuasiQuote _ id l str)
-  = AST.UQuasiQuote <$> annLocNoSema quoterLoc (trfName' id)
+  = AST.UQuasiQuote <$> annLocNoSema quoterLoc (trfName' @n id)
                     <*> annLocNoSema (pure strLoc) (pure $ AST.QQString (unpackFS str))
   where -- assume that there are no white spaces ain the head and the end of the quasi quote
         quoterLoc = do rng <- asks contRange
@@ -47,7 +47,7 @@
 trfSplice' s = unhandledElement "splice" s
 
 -- | TODO: easier with splice decoration
-trfSpliceExpr :: TransformName n r => Located (HsExpr n) -> Trf (AST.USplice (Dom r) RangeStage)
+trfSpliceExpr :: forall n r . TransformName n r => Located (HsExpr n) -> Trf (AST.USplice (Dom r) RangeStage)
 trfSpliceExpr expr =
   do hasDollar <- allTokenLoc AnnThIdSplice
      hasDoubleDollar <- allTokenLoc AnnThIdTySplice
@@ -55,16 +55,16 @@
                    ([], []) -> getLoc expr
                    (_, []) -> updateStart (updateCol (+1)) (getLoc expr)
                    ([], _) -> updateStart (updateCol (+2)) (getLoc expr)
-     case expr of L _ (HsVar (L _ varName)) -> AST.UIdSplice <$> trfName (L newSp varName)
+     case expr of L _ (HsVar (L _ varName)) -> AST.UIdSplice <$> trfName @n (L newSp varName)
                   L _ (HsRecFld fldName) -> AST.UIdSplice <$> trfAmbiguousFieldName' newSp fldName
                   expr -> AST.UParenSplice <$> trfExpr expr
 
-trfBracket' :: TransformName n r => HsBracket n -> Trf (AST.UBracket (Dom r) RangeStage)
+trfBracket' :: forall n r . TransformName n r => HsBracket n -> Trf (AST.UBracket (Dom r) RangeStage)
 trfBracket' (ExpBr expr) = AST.UExprBracket <$> trfExpr expr
 trfBracket' (TExpBr expr) = AST.UExprBracket <$> trfExpr expr
 trfBracket' (VarBr isSingle expr)
   = AST.UExprBracket <$> annLoc createScopeInfo (updateStart (updateCol (if isSingle then (+1) else (+2))) <$> asks contRange)
-      (AST.UVar <$> (annContNoSema (trfName' expr)))
+      (AST.UVar <$> (annContNoSema (trfName' @n expr)))
 trfBracket' (PatBr pat) = AST.UPatternBracket <$> trfPattern pat
 trfBracket' (DecBrL decls) = AST.UDeclsBracket <$> trfDecls decls
 trfBracket' (DecBrG decls) = AST.UDeclsBracket <$> trfDeclsGroup decls
diff --git a/Language/Haskell/Tools/BackendGHC/Types.hs b/Language/Haskell/Tools/BackendGHC/Types.hs
--- a/Language/Haskell/Tools/BackendGHC/Types.hs
+++ b/Language/Haskell/Tools/BackendGHC/Types.hs
@@ -1,10 +1,13 @@
-{-# LANGUAGE ScopedTypeVariables, ViewPatterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns #-}
 
 -- | Functions that convert the type-related elements of the GHC AST to corresponding elements in the Haskell-tools AST representation
 module Language.Haskell.Tools.BackendGHC.Types where
 
 import ApiAnnotation as GHC (AnnKeywordId(..))
 import HsExpr (HsSplice(..))
+import HsExtension (IdP)
 import HsTypes as GHC
 import Id (mkVanillaGlobal)
 import SrcLoc as GHC
@@ -26,7 +29,7 @@
 import {-# SOURCE #-} Language.Haskell.Tools.BackendGHC.TH (trfSplice, trfQuasiQuotation')
 import Language.Haskell.Tools.BackendGHC.Utils
 
-trfType :: TransformName n r => Located (HsType n) -> Trf (Ann AST.UType (Dom r) RangeStage)
+trfType :: forall n r . TransformName n r => Located (HsType n) -> Trf (Ann AST.UType (Dom r) RangeStage)
 trfType typ | RealSrcSpan loce <- getLoc typ
   = do othSplices <- asks typeSplices
        let contSplice = filter (\sp -> case getLoc sp of (RealSrcSpan spLoc) -> spLoc `containsSpan` loce; _ -> False) othSplices
@@ -35,15 +38,16 @@
                                 in typeSpliceInserted lsp (annLocNoSema (pure l) (AST.UTySplice <$> (trfSplice =<< rdrSplice sp)))
   | otherwise = trfLocNoSema trfType' typ
 
-trfType' :: TransformName n r => HsType n -> Trf (AST.UType (Dom r) RangeStage)
+trfType' :: forall n r . TransformName n r => HsType n -> Trf (AST.UType (Dom r) RangeStage)
 trfType' = trfType'' . cleanHsType where
+  trfType'' :: HsType n -> Trf (AST.UType (Dom r) RangeStage)
   trfType'' (HsForAllTy [] typ) = trfType' (unLoc typ)
   trfType'' (HsForAllTy bndrs typ) = AST.UTyForall <$> defineTypeVars (trfBindings bndrs)
                                                    <*> addToScope bndrs (trfType typ)
   trfType'' (HsQualTy (L _ []) typ) = trfType' (unLoc typ)
   trfType'' (HsQualTy ctx typ) = AST.UTyCtx <$> (fromJust . (^. annMaybe) <$> trfCtx atTheStart ctx)
                                             <*> trfType typ
-  trfType'' (HsTyVar _ name) = AST.UTyVar <$> transformingPossibleVar name (trfName name)
+  trfType'' (HsTyVar _ name) = AST.UTyVar <$> transformingPossibleVar name (trfName @n name)
   trfType'' (HsAppsTy apps) | Just (head, args, _) <- getAppsTyHead_maybe apps
     = foldl (\core t -> AST.UTyApp <$> annLocNoSema (pure $ getLoc head `combineSrcSpans` getLoc t) core <*> trfType t) (trfType' (unLoc head)) args
   trfType'' (HsAppTy t1 t2) = AST.UTyApp <$> trfType t1 <*> trfType t2
@@ -53,7 +57,7 @@
   trfType'' (HsTupleTy HsBoxedOrConstraintTuple typs) = AST.UTyTuple <$> trfAnnList ", " trfType' typs
   trfType'' (HsTupleTy HsBoxedTuple typs) = AST.UTyTuple <$> trfAnnList ", " trfType' typs
   trfType'' (HsTupleTy HsUnboxedTuple typs) = AST.UTyUnbTuple <$> trfAnnList ", " trfType' typs
-  trfType'' (HsOpTy t1 op t2) = AST.UTyInfix <$> trfType t1 <*> trfOperator op <*> trfType t2
+  trfType'' (HsOpTy t1 op t2) = AST.UTyInfix <$> trfType t1 <*> trfOperator @n op <*> trfType t2
   trfType'' (HsParTy typ) = AST.UTyParen <$> trfType typ
   trfType'' (HsKindSig typ kind) = AST.UTyKinded <$> trfType typ <*> trfKind kind
   trfType'' (HsSpliceTy qq@(HsQuasiQuote {}) _) = AST.UTyQuasiQuote <$> annContNoSema (trfQuasiQuotation' qq)
@@ -75,10 +79,10 @@
 trfTyVar :: TransformName n r => Located (HsTyVarBndr n) -> Trf (Ann AST.UTyVar (Dom r) RangeStage)
 trfTyVar = trfLocNoSema trfTyVar'
 
-trfTyVar' :: TransformName n r => HsTyVarBndr n -> Trf (AST.UTyVar (Dom r) RangeStage)
-trfTyVar' (UserTyVar name) = AST.UTyVarDecl <$> typeVarTransform (trfName name)
+trfTyVar' :: forall n r . TransformName n r => HsTyVarBndr n -> Trf (AST.UTyVar (Dom r) RangeStage)
+trfTyVar' (UserTyVar name) = AST.UTyVarDecl <$> typeVarTransform (trfName @n name)
                                            <*> (nothing " " "" atTheEnd)
-trfTyVar' (KindedTyVar name kind) = AST.UTyVarDecl <$> typeVarTransform (trfName name)
+trfTyVar' (KindedTyVar name kind) = AST.UTyVarDecl <$> typeVarTransform (trfName @n name)
                                                   <*> trfKindSig (Just kind)
 
 trfCtx :: TransformName n r => Trf SrcLoc -> Located (HsContext n) -> Trf (AnnMaybeG AST.UContext (Dom r) RangeStage)
@@ -99,14 +103,14 @@
 trfAssertion' (cleanHsType -> HsParTy t)
   = trfAssertion' (unLoc t)
 trfAssertion' (cleanHsType -> HsOpTy left op right)
-  = AST.UInfixAssert <$> trfType left <*> trfOperator op <*> trfType right
+  = AST.UInfixAssert <$> trfType left <*> trfOperator @n op <*> trfType right
 trfAssertion' (cleanHsType -> HsTupleTy _ tys)
   = AST.UTupleAssert <$> makeList ", " (after AnnOpenP) (mapM trfAssertion tys)
 trfAssertion' (cleanHsType -> HsWildCardTy _)
   = pure AST.UWildcardAssert
 trfAssertion' (cleanHsType -> t) = case cleanHsType base of
-   HsTyVar _ name -> AST.UClassAssert <$> trfName name <*> trfAnnList " " trfType' args
-   HsEqTy t1 t2 -> AST.UInfixAssert <$> trfType t1 <*> annLocNoSema (tokenLoc AnnTilde) (trfOperator' typeEq) <*> trfType t2
+   HsTyVar _ name -> AST.UClassAssert <$> trfName @n name <*> trfAnnList " " trfType' args
+   HsEqTy t1 t2 -> AST.UInfixAssert <$> trfType t1 <*> annLocNoSema (tokenLoc AnnTilde) (trfOperator' @n typeEq) <*> trfType t2
    HsIParamTy name t -> AST.UImplicitAssert <$> define (focusOn (getLoc name) (trfImplicitName (unLoc name))) <*> trfType t
    t -> unhandledElement "assertion" t
   where (args, _, base) = getArgs t
@@ -115,5 +119,5 @@
         getArgs (HsAppTy (L l ft) at) = case getArgs ft of (args, sp, base) -> (args++[at], sp <|> Just l, base)
         getArgs t = ([], Nothing, t)
 
-        typeEq :: n
-        typeEq = nameFromId (mkVanillaGlobal (tyConName heqTyCon) (tyConKind heqTyCon))
+        typeEq :: IdP n
+        typeEq = nameFromId @n (mkVanillaGlobal (tyConName heqTyCon) (tyConKind heqTyCon))
diff --git a/Language/Haskell/Tools/BackendGHC/Utils.hs b/Language/Haskell/Tools/BackendGHC/Utils.hs
--- a/Language/Haskell/Tools/BackendGHC/Utils.hs
+++ b/Language/Haskell/Tools/BackendGHC/Utils.hs
@@ -1,21 +1,24 @@
 -- | Utility functions for transforming the GHC AST representation into our own.
-{-# LANGUAGE AllowAmbiguousTypes, FlexibleContexts, GADTs, LambdaCase, TypeApplications, ViewPatterns #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ViewPatterns #-}
 
 module Language.Haskell.Tools.BackendGHC.Utils where
 
 import ApiAnnotation (AnnKeywordId)
 import Avail (availNamesWithSelectors, availNames, availName)
 import BasicTypes (StringLiteral(..))
-import CoAxiom as GHC (CoAxiom(..))
 import DynFlags (xopt)
-import FamInstEnv as GHC (FamInst(..), famInstEnvElts)
 import FastString (unpackFS, mkFastString)
 import FieldLabel as GHC (FieldLbl(..))
 import GHC
 import HsSyn
 import HscTypes
-import Var
-import InstEnv as GHC (ClsInst(..), instEnvElts)
 import Language.Haskell.TH.LanguageExtensions (Extension(..))
 import Module as GHC
 import Name
@@ -39,7 +42,7 @@
 import Language.Haskell.Tools.BackendGHC.Monad
 import Language.Haskell.Tools.BackendGHC.SourceMap
 
-createModuleInfo :: ModSummary -> SrcSpan -> [LImportDecl n] -> Trf (Sema.ModuleInfo GHC.Name)
+createModuleInfo :: ModSummary -> SrcSpan -> [LImportDecl n] -> Trf (Sema.ModuleInfo GhcRn)
 createModuleInfo mod nameLoc (filter (not . ideclImplicit . unLoc) -> imports) = do
   let prelude = (xopt ImplicitPrelude $ ms_hspp_opts mod)
                   && all (\idecl -> ("Prelude" /= (GHC.moduleNameString $ unLoc $ ideclName $ unLoc idecl))
@@ -53,7 +56,7 @@
                         (forceElements preludeImports) deps
 
 -- | Creates a semantic information for a name
-createNameInfo :: n -> Trf (NameInfo n)
+createNameInfo :: IdP n -> Trf (NameInfo n)
 createNameInfo name = do locals <- asks localsInScope
                          isDefining <- asks defining
                          return (mkNameInfo locals isDefining name)
@@ -72,28 +75,29 @@
                                  return (mkImplicitNameInfo locals isDefining name rng)
 
 -- | Creates a semantic information for an implicit name
-createImplicitFldInfo :: (GHCName n, HsHasName n) => (a -> n) -> [HsRecField n a] -> Trf ImplicitFieldInfo
+createImplicitFldInfo :: (GHCName n, HsHasName (IdP n)) => (a -> IdP n) -> [HsRecField n a] -> Trf ImplicitFieldInfo
 createImplicitFldInfo select flds = return (mkImplicitFieldInfo (map getLabelAndExpr flds))
   where getLabelAndExpr fld = ( getTheName $ unLoc (getFieldOccName (hsRecFieldLbl fld))
                               , getTheName $ select (hsRecFieldArg fld) )
         getTheName = (\case e:_ -> e; [] -> convProblem "createImplicitFldInfo: missing names") . hsGetNames'
 
 -- | Adds semantic information to an impord declaration. See ImportInfo.
-createImportData :: (GHCName r, HsHasName n) => GHC.ImportDecl n -> Trf (ImportInfo r)
+createImportData :: forall r n . (GHCName r, HsHasName (IdP n)) => GHC.ImportDecl n -> Trf (ImportInfo r)
 createImportData (GHC.ImportDecl _ name pkg _ _ _ _ _ declHiding) =
   do (mod,importedNames) <- getImportedNames (GHC.moduleNameString $ unLoc name) (fmap (unpackFS . sl_fs) pkg)
      names <- liftGhc $ filterM (checkImportVisible declHiding . (^. pName)) importedNames
      -- TODO: only use getFromNameUsing once
      lookedUpNames <- liftGhc $ mapM translatePName $ names
-     lookedUpImported <- liftGhc $ mapM (getFromNameUsing getTopLevelId . (^. pName)) $ importedNames
+     lookedUpImported <- liftGhc $ mapM ((getFromNameUsing @r) getTopLevelId . (^. pName)) $ importedNames
      deps <- lift $ getDeps mod
      -- This function (via getInstances) refers the ghc environment,
      -- we must evaluate the result or the reference may be kept preventing garbage collection.
      return $ mkImportInfo mod (forceElements $ catMaybes lookedUpImported)
                                (forceElements $ catMaybes lookedUpNames)
                                deps
-  where translatePName (PName n p) = do n' <- getFromNameUsing getTopLevelId n
-                                        p' <- maybe (return Nothing) (getFromNameUsing getTopLevelId) p
+  where translatePName :: PName GhcRn -> Ghc (Maybe (PName r))
+        translatePName (PName n p) = do n' <- (getFromNameUsing @r) getTopLevelId n
+                                        p' <- maybe (return Nothing) ((getFromNameUsing @r) getTopLevelId) p
                                         return (PName <$> n' <*> Just p')
 
 getDeps :: Module -> Ghc [Module]
@@ -103,7 +107,7 @@
   case lookupIfaceByModule (hsc_dflags env) (hsc_HPT env) (eps_PIT eps) mod of
     Just ifc -> (mod :) <$> mapM (liftIO . getModule env . fst) (dep_mods (mi_deps ifc))
     Nothing -> return [mod]
-  where getModule env modName = do 
+  where getModule env modName = do
           res <- findHomeModule env modName
           case res of Found _ m -> return m
                       _ -> case lookupPluginModuleWithSuggestions (hsc_dflags env) modName Nothing of
@@ -112,7 +116,7 @@
                              _ -> error $ "getDeps: module not found: " ++ GHC.moduleNameString modName
 
 -- | Get names that are imported from a given import
-getImportedNames :: String -> Maybe String -> Trf (GHC.Module, [PName GHC.Name])
+getImportedNames :: String -> Maybe String -> Trf (GHC.Module, [PName GhcRn])
 getImportedNames name pkg = liftGhc $ do
   hpt <- hsc_HPT <$> getSession
   eps <- getSession >>= liftIO . readIORef . hsc_EPS
@@ -126,7 +130,8 @@
     where availToPName f a = map (\n -> if n == availName a then PName n Nothing else PName n (Just (availName a))) (f a)
 
 -- | Check is a given name is imported from an import with given import specification.
-checkImportVisible :: (HsHasName name, GhcMonad m) => Maybe (Bool, Located [LIE name]) -> GHC.Name -> m Bool
+checkImportVisible :: (HsHasName (IdP name), GhcMonad m)
+                   => Maybe (Bool, Located [LIE name]) -> GHC.Name -> m Bool
 checkImportVisible (Just (isHiding, specs)) name
   | isHiding  = not . or @[] <$> mapM (`ieSpecMatches` name) (map unLoc (unLoc specs))
   | otherwise = or @[] <$> mapM (`ieSpecMatches` name) (map unLoc (unLoc specs))
@@ -138,7 +143,7 @@
 forceElements (a : ls) = let res = forceElements ls
                           in a `seq` res `seq` (a : ls)
 
-ieSpecMatches :: (HsHasName name, GhcMonad m) => IE name -> GHC.Name -> m Bool
+ieSpecMatches :: (HsHasName (IdP name), GhcMonad m) => IE name -> GHC.Name -> m Bool
 ieSpecMatches (concatMap hsGetNames' . HsSyn.ieNames -> ls) name
   | name `elem` ls = return True
 -- ieNames does not consider field names
@@ -477,10 +482,11 @@
 unhandledElementNoPpr :: (Data a) => String -> a -> Trf b
 unhandledElementNoPpr label e = convertionProblem ("Illegal " ++ label ++ ": (ctor: " ++ show (toConstr e) ++ ")")
 
+instance Semigroup SrcSpan where
+  span1@(RealSrcSpan _) <> _     = span1
+  _                     <> span2 = span2
 
 instance Monoid SrcSpan where
-  span1@(RealSrcSpan _) `mappend` _ = span1
-  _ `mappend` span2 = span2
   mempty = noSrcSpan
 
 data ConvertionProblem = ConvertionProblem SrcSpan String
diff --git a/haskell-tools-backend-ghc.cabal b/haskell-tools-backend-ghc.cabal
--- a/haskell-tools-backend-ghc.cabal
+++ b/haskell-tools-backend-ghc.cabal
@@ -1,5 +1,5 @@
 name:                haskell-tools-backend-ghc
-version:             1.0.1.1
+version:             1.1.0.0
 synopsis:            Creating the Haskell-Tools AST from GHC's representations
 description:         This package collects information from various representations of a Haskell program in GHC. Basically GHC provides us with the parsed, the renamed and the type checked representation of the program, if it was type correct. Each version contains different information. For example, the renamed AST contains the unique names of the definitions, however, template haskell splices are already resolved and thus missing from that version of the AST. To get the final representation we perform a transformation on the parsed and renamed representation, and then use the type checked one to look up the types of the names. The whole transformation is defined in the `Modules` module. Other modules define the functions that convert elements of the GHC AST to our AST.
 homepage:            https://github.com/nboldi/haskell-tools
@@ -31,7 +31,7 @@
                      , Language.Haskell.Tools.BackendGHC.SourceMap
                      , Language.Haskell.Tools.BackendGHC.AddTypeInfo
 
-  build-depends:       base              >= 4.10  && < 4.11
+  build-depends:       base              >= 4.11  && < 4.12
                      , transformers      >= 0.5  && < 0.6
                      , references        >= 0.3  && < 0.4
                      , bytestring        >= 0.10 && < 0.11
@@ -40,8 +40,8 @@
                      , containers        >= 0.5  && < 0.6
                      , mtl               >= 2.2  && < 2.3
                      , split             >= 0.2  && < 0.3
-                     , template-haskell  >= 2.12 && < 2.13
-                     , ghc               >= 8.2  && < 8.3
-                     , haskell-tools-ast >= 1.0  && < 1.1
-                     , ghc-boot-th       >= 8.2  && < 8.3
+                     , template-haskell  >= 2.13 && < 2.14
+                     , ghc               >= 8.4  && < 8.5
+                     , haskell-tools-ast >= 1.1  && < 1.2
+                     , ghc-boot-th       >= 8.4  && < 8.5
   default-language:    Haskell2010