haskell-tools-refactor 1.0.0.1 → 1.0.0.2

raw patch · 10 files changed

+96/−86 lines, 10 files

Files

• Language/Haskell/Tools/Refactor/Monad.hs +12/−12
• Language/Haskell/Tools/Refactor/Prepare.hs +18/−10
• Language/Haskell/Tools/Refactor/Refactoring.hs +10/−10
• Language/Haskell/Tools/Refactor/Representation.hs +9/−9
• Language/Haskell/Tools/Refactor/Utils/AST.hs +2/−2
• Language/Haskell/Tools/Refactor/Utils/BindingElem.hs +11/−11
• Language/Haskell/Tools/Refactor/Utils/Helpers.hs +5/−5
• Language/Haskell/Tools/Refactor/Utils/Lists.hs +13/−9
• Language/Haskell/Tools/Refactor/Utils/Monadic.hs +15/−17
• haskell-tools-refactor.cabal +1/−1

@@ -25,45 +25,45 @@   liftGhc :: Ghc a -> m a
 
 -- | A refactoring that only affects one module
-type LocalRefactoring dom = UnnamedModule dom -> LocalRefactor dom (UnnamedModule dom)
+type LocalRefactoring = UnnamedModule -> LocalRefactor UnnamedModule
 
 -- | The type of a refactoring
-type Refactoring dom = ModuleDom dom -> [ModuleDom dom] -> Refactor [RefactorChange dom]
+type Refactoring = ModuleDom -> [ModuleDom] -> Refactor [RefactorChange]
 
 -- | The type of a refactoring that affects the whole project.
-type ProjectRefactoring dom = [ModuleDom dom] -> Refactor [RefactorChange dom]
+type ProjectRefactoring = [ModuleDom] -> Refactor [RefactorChange]
 
 -- | The refactoring monad for a given module
-type LocalRefactor dom = LocalRefactorT dom Refactor
+type LocalRefactor = LocalRefactorT Refactor
 
 -- | The refactoring monad for the whole project
 type Refactor = ExceptT String Ghc
 
 -- | Input and output information for the refactoring
 -- TODO: use multiple states instead of Either
-newtype LocalRefactorT dom m a
+newtype LocalRefactorT m a
   = LocalRefactorT { fromRefactorT :: WriterT [Either GHC.Name (SrcSpan, String, String)]
-                                              (ReaderT (RefactorCtx dom) m) a
+                                              (ReaderT RefactorCtx m) a
                    }
-  deriving ( Functor, Applicative, Monad, MonadReader (RefactorCtx dom)
+  deriving ( Functor, Applicative, Monad, MonadReader RefactorCtx
            , MonadWriter [Either GHC.Name (SrcSpan, String, String)]
            , MonadIO, HasDynFlags, ExceptionMonad, GhcMonad )
 
 -- | The information a refactoring can use
-data RefactorCtx dom
+data RefactorCtx
   = RefactorCtx { refModuleName :: GHC.Module -- ^ The name of the module being refactored. Used for accessing implicit imports.
-                , refCtxRoot :: Ann UModule dom SrcTemplateStage
-                , refCtxImports :: [Ann UImportDecl dom SrcTemplateStage]
+                , refCtxRoot :: Ann UModule IdDom SrcTemplateStage
+                , refCtxImports :: [Ann UImportDecl IdDom SrcTemplateStage]
                 }
 
-instance MonadTrans (LocalRefactorT dom) where
+instance MonadTrans LocalRefactorT where
   lift = LocalRefactorT . lift . lift
 
 instance RefactorMonad Refactor where
   refactError = throwE
   liftGhc = lift
 
-instance RefactorMonad (LocalRefactor dom) where
+instance RefactorMonad LocalRefactor where
   refactError = lift . refactError
   liftGhc = lift . liftGhc
 

@@ -1,10 +1,11 @@-{-# LANGUAGE FlexibleContexts, LambdaCase, MultiWayIf, ScopedTypeVariables, TypeFamilies #-}
+{-# LANGUAGE FlexibleContexts, LambdaCase, MultiWayIf, ScopedTypeVariables, TypeFamilies, TupleSections #-}
 -- | Defines utility methods that prepare Haskell modules for refactoring
 module Language.Haskell.Tools.Refactor.Prepare where
 
-import Control.Exception (Exception(..), throwIO, throw)
+import Control.Exception
 import Control.Monad
 import Control.Monad.IO.Class (MonadIO(..))
+import Data.IORef
 import Data.List ((\\), isSuffixOf)
 import Data.List.Split (splitOn)
 import Data.Maybe (Maybe(..), fromMaybe, fromJust)
@@ -19,7 +20,10 @@ import qualified GHC (loadModule)
 import GHC.Paths ( libdir )
 import GhcMonad
-import HscTypes (HscEnv(..), ModSummary(..))
+import HscTypes
+import TcRnTypes
+import TcRnMonad
+import TcRnDriver
 import Linker (unload)
 import Outputable (Outputable(..), showSDocUnsafe)
 import Packages (initPackages)
@@ -36,7 +40,7 @@ 
 
 -- | A quick function to try the refactorings
-tryRefactor :: (RealSrcSpan -> Refactoring IdDom) -> String -> String -> IO ()
+tryRefactor :: (RealSrcSpan -> Refactoring) -> String -> String -> IO ()
 tryRefactor refact moduleName span
   = runGhc (Just libdir) $ do
       initGhcFlags
@@ -48,7 +52,7 @@                   Left err -> liftIO $ putStrLn err
 
 -- | Adjust the source range to be applied to the refactored module
-correctRefactorSpan :: UnnamedModule dom -> RealSrcSpan -> RealSrcSpan
+correctRefactorSpan :: UnnamedModule -> RealSrcSpan -> RealSrcSpan
 correctRefactorSpan mod sp = mkRealSrcSpan (updateSrcFile fileName $ realSrcSpanStart sp)
                                            (updateSrcFile fileName $ realSrcSpanEnd sp)
   where fileName = case srcSpanStart $ getRange mod of RealSrcLoc loc -> srcLocFile loc
@@ -79,22 +83,26 @@ 
 -- | Initialize GHC flags to default values that support refactoring
 initGhcFlags :: Ghc ()
-initGhcFlags = initGhcFlags' False
+initGhcFlags = initGhcFlags' False True
 
 initGhcFlagsForTest :: Ghc ()
-initGhcFlagsForTest = do initGhcFlags' True
+initGhcFlagsForTest = do initGhcFlags' True False
                          dfs <- getSessionDynFlags
                          void $ setSessionDynFlags $ dfs { hscTarget = HscAsm }
 
 -- | Sets up basic flags and settings for GHC
-initGhcFlags' :: Bool -> Ghc ()
-initGhcFlags' needsCodeGen = do
+initGhcFlags' :: Bool -> Bool -> Ghc ()
+initGhcFlags' needsCodeGen errorsSuppressed = do
   dflags <- getSessionDynFlags
   env <- getSession
   liftIO $ unload env [] -- clear linker state if ghc was used in the same process
   void $ setSessionDynFlags
     $ flip gopt_set Opt_KeepRawTokenStream
     $ flip gopt_set Opt_NoHsMain
+    $ (if errorsSuppressed then flip gopt_set Opt_DeferTypeErrors
+                                  . flip gopt_set Opt_DeferTypedHoles	 
+                                  . flip gopt_set Opt_DeferOutOfScopeVariables 
+                           else id)
     $ dflags { importPaths = []
              , hscTarget = if needsCodeGen then HscInterpreted else HscNothing
              , ghcLink = if needsCodeGen then LinkInMemory else NoLink
@@ -155,7 +163,7 @@ -- | The final version of our AST, with type infromation added
 type TypedModule = Ann AST.UModule IdDom SrcTemplateStage
 
--- | Get the typed representation from a type-correct program.
+-- | Get the typed representation of a Haskell module.
 parseTyped :: ModSummary -> Ghc TypedModule
 parseTyped modSum = withAlteredDynFlags (return . normalizeFlags) $ do
   let hasCppExtension = Cpp `xopt` ms_hspp_opts modSum

@@ -13,27 +13,27 @@ import Language.Haskell.Tools.Refactor.Representation (RefactorChange, ModuleDom)
 
 -- | The signature and behavior of one refactoring that can be executed.
-data RefactoringChoice dom
+data RefactoringChoice
   = NamingRefactoring { refactoringName :: String
-                      , namingRefactoring :: RealSrcSpan -> String -> Refactoring dom
+                      , namingRefactoring :: RealSrcSpan -> String -> Refactoring
                       }
   | SelectionRefactoring { refactoringName :: String
-                         , selectionRefactoring :: RealSrcSpan -> Refactoring dom
+                         , selectionRefactoring :: RealSrcSpan -> Refactoring
                          }
   | ModuleRefactoring { refactoringName :: String
-                      , moduleRefactoring :: Refactoring dom
+                      , moduleRefactoring :: Refactoring
                       }
   | ProjectRefactoring { refactoringName :: String
-                       , projectRefactoring :: ProjectRefactoring dom
+                       , projectRefactoring :: ProjectRefactoring
                        }
 
 -- | Executes a given command (choosen from the set of available refactorings) on the selected
 -- module and given other modules.
-performCommand :: [RefactoringChoice dom] -- ^ The set of available refactorings
+performCommand :: [RefactoringChoice] -- ^ The set of available refactorings
                     -> [String] -- ^ The refactoring command
-                    -> Either FilePath (ModuleDom dom) -- ^ The module in which the refactoring is performed
-                    -> [ModuleDom dom] -- ^ Other modules
-                    -> Ghc (Either String [RefactorChange dom])
+                    -> Either FilePath ModuleDom -- ^ The module in which the refactoring is performed
+                    -> [ModuleDom] -- ^ Other modules
+                    -> Ghc (Either String [RefactorChange])
 performCommand refactorings (name:args) mod mods =
     case (refactoring, mod, args) of
       (Just (NamingRefactoring _ trf), Right mod, (sp:newName:_))
@@ -54,5 +54,5 @@   where refactoring = find ((== name) . refactoringName) refactorings
 
 -- | Gets the name of possible refactorings.
-refactorCommands :: [RefactoringChoice dom] -> [String]
+refactorCommands :: [RefactoringChoice] -> [String]
 refactorCommands = map refactoringName

@@ -16,10 +16,10 @@ import Language.Haskell.Tools.AST as AST
 
 -- | A type for the input and result of refactoring a module
-type UnnamedModule dom = Ann AST.UModule dom SrcTemplateStage
+type UnnamedModule = Ann AST.UModule IdDom SrcTemplateStage
 
 -- | The name of the module and the AST
-type ModuleDom dom = (SourceFileKey, UnnamedModule dom)
+type ModuleDom = (SourceFileKey, UnnamedModule)
 
 -- | Module name and marker to separate .hs-boot module definitions. Specifies a source file in a working directory.
 data SourceFileKey = SourceFileKey { _sfkFileName :: FilePath
@@ -28,13 +28,13 @@   deriving (Eq, Ord, Show)
 
 -- | Change in the project, modification or removal of a module.
-data RefactorChange dom = ContentChanged { fromContentChanged :: ModuleDom dom }
-                        | ModuleRemoved { removedModuleName :: String }
-                        | ModuleCreated { createdModuleName :: String
-                                        , createdModuleContent :: UnnamedModule dom
-                                        , sameLocation :: SourceFileKey
-                                        }
-instance Show (RefactorChange dom) where
+data RefactorChange = ContentChanged { fromContentChanged :: ModuleDom }
+                    | ModuleRemoved { removedModuleName :: String }
+                    | ModuleCreated { createdModuleName :: String
+                                    , createdModuleContent :: UnnamedModule
+                                    , sameLocation :: SourceFileKey
+                                    }
+instance Show RefactorChange where
   show (ContentChanged (n, _)) = "ContentChanged (" ++ show n  ++ ")"
   show (ModuleRemoved n) = "ModuleRemoved " ++ n
   show (ModuleCreated n _ other) = "ModuleCreated " ++ n ++ " (" ++ show other ++ ")"

@@ -15,13 +15,13 @@ import Data.Either (Either(..))
 
 -- | Remove a separator from the AST while keeping the textual parts of it that should not be removed (like preprocessor pragmas).
-removeSeparator :: ([SourceTemplateTextElem], SrcSpan) -> LocalRefactor dom ()
+removeSeparator :: ([SourceTemplateTextElem], SrcSpan) -> LocalRefactor ()
 removeSeparator (txts, range) = tell [Right (range, intercalate lineEnd staying, lineEnd)]
   where staying = catMaybes $ map (\case StayingText str _ -> Just str; _ -> Nothing) txts
         lineEnd = head $ (catMaybes $ map (\case StayingText _ lnEnd -> Just lnEnd; _ -> Nothing) txts) ++ [""]
 
 -- | Remove an element from the AST while keeping the textual parts of it that should not be removed (like preprocessor pragmas).
-removeChild :: (SourceInfoTraversal e) => e dom SrcTemplateStage -> LocalRefactor dom ()
+removeChild :: (SourceInfoTraversal e) => e dom SrcTemplateStage -> LocalRefactor ()
 removeChild e = tell $ map Right $ keptText e
 
 -- | Extracts all text elements that should be kept

@@ -11,31 +11,31 @@ class NamedElement d => BindingElem d where
 
   -- | Accesses a type signature definition in a local or top-level definition
-  sigBind :: Simple Partial (Ann d dom SrcTemplateStage) (TypeSignature dom)
+  sigBind :: Simple Partial (Ann d IdDom SrcTemplateStage) TypeSignature
 
   -- | Accesses a value or function definition in a local or top-level definition
-  valBind :: Simple Partial (Ann d dom SrcTemplateStage) (ValueBind dom)
+  valBind :: Simple Partial (Ann d IdDom SrcTemplateStage) ValueBind
 
   -- | Accesses a type signature definition in a local or top-level definition
-  fixitySig :: Simple Partial (Ann d dom SrcTemplateStage) (FixitySignature dom)
+  fixitySig :: Simple Partial (Ann d IdDom SrcTemplateStage) FixitySignature
 
   -- | Creates a new definition from a type signature
-  createTypeSig :: TypeSignature dom -> Ann d dom SrcTemplateStage
+  createTypeSig :: TypeSignature -> Ann d IdDom SrcTemplateStage
 
   -- | Creates a new definition from a value or function definition
-  createBinding :: ValueBind dom -> Ann d dom SrcTemplateStage
+  createBinding :: ValueBind -> Ann d IdDom SrcTemplateStage
 
   -- | Creates a new fixity signature
-  createFixitySig :: FixitySignature dom -> Ann d dom SrcTemplateStage
+  createFixitySig :: FixitySignature -> Ann d IdDom SrcTemplateStage
 
   -- | Checks if a given definition is a type signature
-  isTypeSig :: Ann d dom SrcTemplateStage -> Bool
+  isTypeSig :: Ann d IdDom SrcTemplateStage -> Bool
 
   -- | Checks if a given definition is a function or value binding
-  isBinding :: Ann d dom SrcTemplateStage -> Bool
+  isBinding :: Ann d IdDom SrcTemplateStage -> Bool
 
   -- | Checks if a given definition is a fixity signature
-  isFixitySig :: Ann d dom SrcTemplateStage -> Bool
+  isFixitySig :: Ann d IdDom SrcTemplateStage -> Bool
 
 instance BindingElem UDecl where
   sigBind = declTypeSig
@@ -65,11 +65,11 @@   isFixitySig LocalFixity {} = True
   isFixitySig _ = False
 
-getValBindInList :: (BindingElem d) => RealSrcSpan -> AnnListG d dom SrcTemplateStage -> Maybe (ValueBind dom)
+getValBindInList :: BindingElem d => RealSrcSpan -> AnnList d -> Maybe ValueBind
 getValBindInList sp ls = case ls ^? valBindsInList & filtered (isInside sp) of
   [] -> Nothing
   [n] -> Just n
   _ -> error "getValBindInList: Multiple nodes"
 
-valBindsInList :: BindingElem d => Simple Traversal (AnnListG d dom SrcTemplateStage) (ValueBind dom)
+valBindsInList :: BindingElem d => Simple Traversal (AnnList d) ValueBind
 valBindsInList = annList & valBind

@@ -14,16 +14,16 @@ 
 import SrcLoc (srcSpanStart)
 
-replaceWithJust :: Ann e dom SrcTemplateStage -> AnnMaybe e dom -> AnnMaybe e dom
+replaceWithJust :: Ann e IdDom SrcTemplateStage -> AnnMaybe e -> AnnMaybe e
 replaceWithJust e = annMaybe .= Just e
 
-replaceWithNothing :: AnnMaybe e dom -> AnnMaybe e dom
+replaceWithNothing :: AnnMaybe e -> AnnMaybe e
 replaceWithNothing = annMaybe .= Nothing
 
 -- | Remove the container (where or let) when the last binding is removed.
-removeEmptyBnds :: Simple Traversal (Module dom) (ValueBind dom)
-                     -> Simple Traversal (Module dom) (Expr dom)
-                     -> AST.Module dom -> AST.Module dom
+removeEmptyBnds :: Simple Traversal Module ValueBind
+                     -> Simple Traversal Module Expr
+                     -> AST.Module -> AST.Module
 removeEmptyBnds binds exprs = (binds .- removeEmptyBindsAndGuards) . (exprs .- removeEmptyLetsAndStmts)
   where removeEmptyBindsAndGuards sb@(SimpleBind _ _ _)
           = (valBindLocals .- removeIfEmpty) . (valBindRhs .- removeEmptyGuards) $ sb

@@ -17,10 +17,11 @@ 
 -- | Filters the elements of the list. By default it removes the separator before the element.
 -- Of course, if the first element is removed, the following separator is removed as well.
-filterList :: SourceInfoTraversal e => (Ann e dom SrcTemplateStage -> Bool) -> AnnList e dom -> AnnList e dom
+filterList :: SourceInfoTraversal e => (Ann e IdDom SrcTemplateStage -> Bool) -> AnnList e -> AnnList e
 filterList pred = filterListIndexed (const pred)
 
-filterListIndexed :: SourceInfoTraversal e => (Int -> Ann e dom SrcTemplateStage -> Bool) -> AnnList e dom -> AnnList e dom
+filterListIndexed :: SourceInfoTraversal e => (Int -> Ann e IdDom SrcTemplateStage -> Bool) 
+                                                -> AnnList e -> AnnList e
 filterListIndexed pred (AnnListG (NodeInfo sema src) elems)
   =  AnnListG (NodeInfo sema (srcTmpIndented .- fmap filterIndents $ srcTmpSeparators .- filterSeparators $ src)) filteredElems
   where elementsKept = findIndices (uncurry pred) (zip [0..] elems)
@@ -29,11 +30,13 @@         filterSeparators = take (length elementsKept - 1) . sublist elementsKept
 
 -- | A version of filterList that cares about keeping non-removable code elements (like preprocessor pragmas)
-filterListSt :: SourceInfoTraversal e => (Ann e dom SrcTemplateStage -> Bool) -> AnnList e dom -> LocalRefactor dom (AnnList e dom)
+filterListSt :: SourceInfoTraversal e => (Ann e IdDom SrcTemplateStage -> Bool) -> AnnList e 
+                                           -> LocalRefactor (AnnList e)
 filterListSt pred = filterListIndexedSt (const pred)
 
 -- | A version of filterListIndexed that cares about keeping non-removable code elements (like preprocessor pragmas)
-filterListIndexedSt :: SourceInfoTraversal e => (Int -> Ann e dom SrcTemplateStage -> Bool) -> AnnList e dom -> LocalRefactor dom (AnnList e dom)
+filterListIndexedSt :: SourceInfoTraversal e => (Int -> Ann e IdDom SrcTemplateStage -> Bool) 
+                                                  -> AnnList e -> LocalRefactor (AnnList e)
 filterListIndexedSt pred ls@(AnnListG _ elems)
   | all (uncurry pred) (zip [0..] elems)
   = return ls
@@ -69,9 +72,9 @@ 
 -- | Inserts the element in the places where the two positioning functions (one checks the element before, one the element after)
 -- allows the placement.
-insertWhere :: Bool -> Ann e dom SrcTemplateStage -> (Maybe (Ann e dom SrcTemplateStage) -> Bool)
-                 -> (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> AnnList e dom
-                 -> AnnList e dom
+insertWhere :: Bool -> Ann e IdDom SrcTemplateStage -> (Maybe (Ann e IdDom SrcTemplateStage) -> Bool)
+                 -> (Maybe (Ann e IdDom SrcTemplateStage) -> Bool) -> AnnList e
+                 -> AnnList e
 insertWhere indented e before after al
   = let index = insertIndex before after (al ^? annList)
      in case index of
@@ -85,7 +88,8 @@         isEmptyAnnList = (null :: [x] -> Bool) $ (al ^? annList)
 
 -- | Checks where the element will be inserted given the two positioning functions.
-insertIndex :: (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> [Ann e dom SrcTemplateStage] -> Maybe Int
+insertIndex :: (Maybe (Ann e IdDom SrcTemplateStage) -> Bool) -> (Maybe (Ann e IdDom SrcTemplateStage) -> Bool) 
+                 -> [Ann e IdDom SrcTemplateStage] -> Maybe Int
 insertIndex before after []
   | before Nothing && after Nothing = Just 0
   | otherwise = Nothing
@@ -104,7 +108,7 @@ 
 -- | Gets the elements and separators from a list. The first separator is zipped to the second element.
 -- To the first element, the "" string is zipped.
-zipWithSeparators :: AnnList e dom -> [(([SourceTemplateTextElem], SrcSpan), Ann e dom SrcTemplateStage)]
+zipWithSeparators :: AnnList e -> [(([SourceTemplateTextElem], SrcSpan), Ann e IdDom SrcTemplateStage)]
 zipWithSeparators (AnnListG (NodeInfo _ src) elems)
   | [] <- src ^. srcTmpSeparators
   = zip (([], noSrcSpan) : repeat ([NormalText $ src ^. srcTmpDefaultSeparator], noSrcSpan)) elems

@@ -24,23 +24,20 @@ import Language.Haskell.Tools.PrettyPrint.Prepare
 import Language.Haskell.Tools.Refactor.Monad
 import Language.Haskell.Tools.Refactor.Representation (RefactorChange(..), ModuleDom, UnnamedModule)
-import Language.Haskell.Tools.Rewrite
+import Language.Haskell.Tools.Rewrite as HT
 
 -- | Performs the given refactoring, transforming it into a Ghc action
-runRefactor :: ModuleDom dom -> [ModuleDom dom] -> Refactoring dom -> Ghc (Either String [RefactorChange dom])
+runRefactor :: ModuleDom -> [ModuleDom] -> Refactoring -> Ghc (Either String [RefactorChange])
 runRefactor mod mods trf = runExceptT $ trf mod mods
 
 -- | Wraps a refactoring that only affects one module. Performs the per-module finishing touches.
-localRefactoring :: HasModuleInfo dom => LocalRefactoring dom -> Refactoring dom
+localRefactoring :: LocalRefactoring -> Refactoring
 localRefactoring ref (name, mod) _
   = (\m -> [ContentChanged (name, m)]) <$> localRefactoringRes id mod (ref mod)
 
 -- | Transform the result of the local refactoring
-localRefactoringRes :: HasModuleInfo dom
-                    => ((UnnamedModule dom -> UnnamedModule dom) -> a -> a)
-                          -> UnnamedModule dom
-                          -> LocalRefactor dom a
-                          -> Refactor a
+localRefactoringRes :: ((UnnamedModule -> UnnamedModule) -> a -> a)
+                          -> UnnamedModule -> LocalRefactor a -> Refactor a
 localRefactoringRes access mod trf
   = let init = RefactorCtx (semanticsModule $ mod ^. semantics) mod (mod ^? modImports&annList)
      in flip runReaderT init $ do (mod, recorded) <- runWriterT (fromRefactorT trf)
@@ -116,13 +113,13 @@    takeWhatPrecedes _ _ _ _ elems = return elems
 
 -- | Adds the imports that bring names into scope that are needed by the refactoring
-addGeneratedImports :: [GHC.Name] -> Ann UModule dom SrcTemplateStage -> Ann UModule dom SrcTemplateStage
+addGeneratedImports :: [GHC.Name] -> HT.Module -> HT.Module
 addGeneratedImports names m = modImports&annListElems .- (++ addImports names) $ m
-  where addImports :: [GHC.Name] -> [Ann UImportDecl dom SrcTemplateStage]
+  where addImports :: [GHC.Name] -> [HT.ImportDecl]
         addImports names = map createImport $ groupBy ((==) `on` GHC.nameModule) $ filter (isJust . GHC.nameModule_maybe) $ nub $ sort names
 
         -- TODO: group names like constructors into correct IESpecs
-        createImport :: [GHC.Name] -> Ann UImportDecl dom SrcTemplateStage
+        createImport :: [GHC.Name] -> HT.ImportDecl
         -- works on groupby result, so list is nonempty
         createImport names = mkImportDecl False True False Nothing (mkModuleName $ GHC.moduleNameString $ GHC.moduleName $ GHC.nameModule $ head names)
                                           Nothing (Just $ mkImportSpecList (map (\n -> mkIESpec (mkUnqualName' n) Nothing) names))
@@ -142,15 +139,15 @@   Just mod -> GHC.moduleNameString (GHC.moduleName mod) ++ "." ++ GHC.occNameString (GHC.nameOccName name)
   Nothing -> GHC.occNameString (GHC.nameOccName name)
 
-referenceName :: (HasImportInfo dom, HasModuleInfo dom) => GHC.Name -> LocalRefactor dom (Ann UName dom SrcTemplateStage)
+referenceName :: GHC.Name -> LocalRefactor (Ann UName IdDom SrcTemplateStage)
 referenceName = referenceName' mkQualName'
 
-referenceOperator :: (HasImportInfo dom, HasModuleInfo dom) => GHC.Name -> LocalRefactor dom (Ann UOperator dom SrcTemplateStage)
+referenceOperator :: GHC.Name -> LocalRefactor (Ann UOperator IdDom SrcTemplateStage)
 referenceOperator = referenceName' mkQualOp'
 
 -- | Create a name that references the definition. Generates an import if the definition is not yet imported.
-referenceName' :: (HasImportInfo dom, HasModuleInfo dom)
-               => ([String] -> GHC.Name -> Ann nt dom SrcTemplateStage) -> GHC.Name -> LocalRefactor dom (Ann nt dom SrcTemplateStage)
+referenceName' :: ([String] -> GHC.Name -> Ann nt IdDom SrcTemplateStage) -> GHC.Name 
+                    -> LocalRefactor (Ann nt IdDom SrcTemplateStage)
 referenceName' makeName name
   | name `elem` registeredNamesFromPrelude || qualifiedName name `elem` otherNamesFromPrelude
   = return $ makeName [] name -- imported from prelude
@@ -168,11 +165,12 @@   where moduleParts = maybe [] (splitOn "." . GHC.moduleNameString . GHC.moduleName) . GHC.nameModule_maybe
 
 -- | Reference the name by the shortest suitable import
-referenceBy :: ([String] -> GHC.Name -> Ann nt dom SrcTemplateStage) -> GHC.Name -> [Ann UImportDecl dom SrcTemplateStage] -> Ann nt dom SrcTemplateStage
+referenceBy :: ([String] -> GHC.Name -> Ann nt IdDom SrcTemplateStage) -> GHC.Name 
+                 -> [Ann UImportDecl IdDom SrcTemplateStage] -> Ann nt IdDom SrcTemplateStage
 referenceBy makeName name imps =
   let prefixes = map importQualifier imps
    in makeName (minimumBy (compare `on` (length . concat)) prefixes) name
-  where importQualifier :: Ann UImportDecl dom SrcTemplateStage -> [String]
+  where importQualifier :: Ann UImportDecl IdDom SrcTemplateStage -> [String]
         importQualifier imp
           = if isJust (imp ^? importQualified&annJust)
               then case imp ^? importAs&annJust&importRename of

@@ -1,5 +1,5 @@ name:                haskell-tools-refactor
-version:             1.0.0.1
+version:             1.0.0.2
 synopsis:            Refactoring Tool for Haskell
 description:         Contains a set of refactorings based on the Haskell-Tools framework to easily transform a Haskell program. For the descriptions of the implemented refactorings, see the homepage.
 homepage:            https://github.com/haskell-tools/haskell-tools