removing CPP from test, thus formatting

1 files changed, 1086 insertions, 1109 deletions

diff --git a/test/Main.hs b/test/Main.hs
index a1e774a..9c009e0 100644
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -8,31 +7,31 @@
 
 module Main where
 
-import Control.Exception (try)
-import Control.Monad.Logger (runLoggingT)
-import qualified Data.ByteString as BS
-import qualified Data.Generics.Uniplate.Data as U
-import qualified Data.HashMap.Strict as HM
-import qualified Data.IntMap as IM
-import qualified Data.IntervalMap.Strict as IVM
-import qualified Data.Set as S
-import qualified Data.Text as T
-import qualified Data.Text.Encoding as TE
-import qualified Data.Vector as V
-import Data.Version (makeVersion)
-import HaskellCodeExplorer.AST.TypecheckedSource (removeOverlappingInterval)
-import HaskellCodeExplorer.PackageInfo
-import HaskellCodeExplorer.Preprocessor
-import HaskellCodeExplorer.Types
-import qualified HaskellCodeExplorer.Types as HCE
-import System.Directory
-  ( findExecutable
-  , getCurrentDirectory
-  , withCurrentDirectory
-  )
-import System.FilePath ((</>))
-import System.Process (readProcess)
-import Test.Hspec
+import           Control.Exception              ( try )
+import           Control.Monad.Logger           ( runLoggingT )
+import qualified Data.ByteString               as BS
+import qualified Data.Generics.Uniplate.Data   as U
+import qualified Data.HashMap.Strict           as HM
+import qualified Data.IntMap                   as IM
+import qualified Data.IntervalMap.Strict       as IVM
+import qualified Data.Set                      as S
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as TE
+import qualified Data.Vector                   as V
+import           Data.Version                   ( makeVersion )
+import           HaskellCodeExplorer.AST.TypecheckedSource
+                                                ( removeOverlappingInterval )
+import           HaskellCodeExplorer.PackageInfo
+import           HaskellCodeExplorer.Preprocessor
+import           HaskellCodeExplorer.Types
+import qualified HaskellCodeExplorer.Types     as HCE
+import           System.Directory               ( findExecutable
+                                                , getCurrentDirectory
+                                                , withCurrentDirectory
+                                                )
+import           System.FilePath                ( (</>) )
+import           System.Process                 ( readProcess )
+import           Test.Hspec
 
 testPackageDir :: FilePath
 testPackageDir = "test/test-package"
@@ -50,233 +49,266 @@ packageInfoSpec :: FilePath -> Spec
 packageInfoSpec currentDir = do
   eitherPackageInfo <- runIO $ buildAndIndexTestPackage currentDir
   case eitherPackageInfo of
-    Right HCE.PackageInfo{id=pkgId, ..} -> do
+    Right HCE.PackageInfo { id = pkgId, ..} -> do
       describe "createPackageInfo" $ do
-        it "returns valid package id" $
-          pkgId `shouldBe`
-          PackageId "test-package" (makeVersion [0, 1, 0, 0])
+        it "returns valid package id" $ pkgId `shouldBe` PackageId
+          "test-package"
+          (makeVersion [0, 1, 0, 0])
         it "returns valid list of module paths" $ do
-          let paths =
-                HM.fromList
-                  [ ( HaskellModulePath {getHaskellModulePath = "app/Main.hs"}
-                    , ())
-                  , ( HaskellModulePath {getHaskellModulePath = "src/Types.hs"}
-                    , ())
-                  , ( HaskellModulePath {getHaskellModulePath = "test/Spec.hs"}
-                    , ())
-                  , ( HaskellModulePath {getHaskellModulePath = "src/Lib.hs"}
-                    , ())
-                  ]
-          (HM.map (const ()))
-            moduleMap `shouldBe`
-            paths
+          let
+            paths = HM.fromList
+              [ (HaskellModulePath { getHaskellModulePath = "app/Main.hs" }, ())
+              , ( HaskellModulePath { getHaskellModulePath = "src/Types.hs" }
+                , ()
+                )
+              , ( HaskellModulePath { getHaskellModulePath = "test/Spec.hs" }
+                , ()
+                )
+              , (HaskellModulePath { getHaskellModulePath = "src/Lib.hs" }, ())
+              ]
+          (HM.map (const ())) moduleMap `shouldBe` paths
         it "returns valid list of module names" $ do
-          let names =
-                HM.fromList
-                  [ ( HaskellModuleName {getHaskellModuleName = "Types"}
-                    , HM.fromList
-                        [ ( ComponentId {getComponentId = "lib"}
-                          , HaskellModulePath
-                              {getHaskellModulePath = "src/Types.hs"})
-                        ])
-                  , ( HaskellModuleName {getHaskellModuleName = "Main"}
-                    , HM.fromList
-                        [ ( ComponentId
-                              {getComponentId = "exe-test-package-exe"}
-                          , HaskellModulePath
-                              {getHaskellModulePath = "app/Main.hs"})
-                        , ( ComponentId
-                              {getComponentId = "test-test-package-test"}
-                          , HaskellModulePath
-                              {getHaskellModulePath = "test/Spec.hs"})
-                        ])
-                  , ( HaskellModuleName {getHaskellModuleName = "Lib"}
-                    , HM.fromList
-                        [ ( ComponentId {getComponentId = "lib"}
-                          , HaskellModulePath
-                              {getHaskellModulePath = "src/Lib.hs"})
-                        ])
+          let
+            names = HM.fromList
+              [ ( HaskellModuleName { getHaskellModuleName = "Types" }
+                , HM.fromList
+                  [ ( ComponentId { getComponentId = "lib" }
+                    , HaskellModulePath { getHaskellModulePath = "src/Types.hs"
+                                        }
+                    )
+                  ]
+                )
+              , ( HaskellModuleName { getHaskellModuleName = "Main" }
+                , HM.fromList
+                  [ ( ComponentId { getComponentId = "exe-test-package-exe" }
+                    , HaskellModulePath { getHaskellModulePath = "app/Main.hs" }
+                    )
+                  , ( ComponentId { getComponentId = "test-test-package-test" }
+                    , HaskellModulePath { getHaskellModulePath = "test/Spec.hs"
+                                        }
+                    )
                   ]
-          moduleNameMap `shouldBe`
-            names
+                )
+              , ( HaskellModuleName { getHaskellModuleName = "Lib" }
+                , HM.fromList
+                  [ ( ComponentId { getComponentId = "lib" }
+                    , HaskellModulePath { getHaskellModulePath = "src/Lib.hs" }
+                    )
+                  ]
+                )
+              ]
+          moduleNameMap `shouldBe` names
       let mbModuleInfo =
-            HM.lookup
-              (HCE.HaskellModulePath "src/Lib.hs")
-              moduleMap
+            HM.lookup (HCE.HaskellModulePath "src/Lib.hs") moduleMap
       case mbModuleInfo of
         Just modInfo -> moduleInfoSpec modInfo
-        Nothing -> return ()
+        Nothing      -> return ()
     Left e -> runIO $ putStrLn e >> return ()
 
 moduleInfoSpec :: ModuleInfo -> Spec
-moduleInfoSpec HCE.ModuleInfo{id = _, ..} =
-  describe "createModuleInfo" $ do
-    it "returns valid module name" $
-      name `shouldBe`
-      HCE.HaskellModuleName "Lib"
-    it "returns valid list of declarations " $
-      declarations `shouldBe` testDeclarations
-    it "returns valid source code " $ do
-      let sourceCodeLines =
-            V.fromList
-              [ "module Lib"
-              , "    ( someFunc"
-              , "    ) where"
-              , ""
-              , "import Types(Test(..))"
-              , ""
-              , "-- | someFunc documentation"
-              , "someFunc :: IO ()"
-              , "someFunc = putStrLn \"someFunc\""
-              , ""
-              , "-- | mkTest documentation"
-              , "mkTest :: Int -> Test"
-              , "mkTest i = Test i"
-              , ""
-              ]
-      source `shouldBe` sourceCodeLines
-    it "returns valid map of expressions" $
-      exprInfoMap `shouldBe` testExprInfoMap
-#if MIN_VERSION_GLASGOW_HASKELL(8,2,2,0)
-    it "returns valid map of identifiers " $
-      let removeLocationInfo :: HCE.LocationInfo -> HCE.LocationInfo
-          removeLocationInfo _ = HCE.UnknownLocation ""
-          removePackageVersionFromExternalId :: HCE.ExternalId -> HCE.ExternalId
-          removePackageVersionFromExternalId extId@(HCE.ExternalId textId) = case T.splitOn "|" textId of
-            pId:rest -> case T.splitOn "-" pId of
-              packageIdParts@(_:_) -> HCE.ExternalId $ T.intercalate "|" ((T.intercalate "-" (init packageIdParts)) : rest)
+moduleInfoSpec HCE.ModuleInfo { id = _, ..} = describe "createModuleInfo" $ do
+  it "returns valid module name" $ name `shouldBe` HCE.HaskellModuleName "Lib"
+  it "returns valid list of declarations "
+    $          declarations
+    `shouldBe` testDeclarations
+  it "returns valid source code " $ do
+    let sourceCodeLines = V.fromList
+          [ "module Lib"
+          , "    ( someFunc"
+          , "    ) where"
+          , ""
+          , "import Types(Test(..))"
+          , ""
+          , "-- | someFunc documentation"
+          , "someFunc :: IO ()"
+          , "someFunc = putStrLn \"someFunc\""
+          , ""
+          , "-- | mkTest documentation"
+          , "mkTest :: Int -> Test"
+          , "mkTest i = Test i"
+          , ""
+          ]
+    source `shouldBe` sourceCodeLines
+  it "returns valid map of expressions" $ exprInfoMap `shouldBe` testExprInfoMap
+  it "returns valid map of identifiers "
+    $ let
+        removeLocationInfo :: HCE.LocationInfo -> HCE.LocationInfo
+        removeLocationInfo _ = HCE.UnknownLocation ""
+        removePackageVersionFromExternalId :: HCE.ExternalId -> HCE.ExternalId
+        removePackageVersionFromExternalId extId@(HCE.ExternalId textId) =
+          case T.splitOn "|" textId of
+            pId : rest -> case T.splitOn "-" pId of
+              packageIdParts@(_ : _) -> HCE.ExternalId $ T.intercalate
+                "|"
+                ((T.intercalate "-" (init packageIdParts)) : rest)
               _ -> extId
-            _ ->  extId
-          cleanup :: HCE.IdentifierInfoMap -> HCE.IdentifierInfoMap
-          cleanup = U.transformBi removeLocationInfo . U.transformBi removePackageVersionFromExternalId
-       in
+            _ -> extId
+        cleanup :: HCE.IdentifierInfoMap -> HCE.IdentifierInfoMap
+        cleanup = U.transformBi removeLocationInfo
+          . U.transformBi removePackageVersionFromExternalId
+      in
         cleanup idInfoMap `shouldBe` cleanup testIdInfoMap
-#endif
-    it "returns valid map of identifier occurrences" $
-      idOccMap `shouldBe` testIdOccMap
+  it "returns valid map of identifier occurrences"
+    $          idOccMap
+    `shouldBe` testIdOccMap
 
 stackYamlArg :: [String]
-#if MIN_VERSION_GLASGOW_HASKELL(8,6,5,0)
 stackYamlArg = []
-#elif MIN_VERSION_GLASGOW_HASKELL(8,6,4,0)
-stackYamlArg = ["--stack-yaml=stack-8.6.4.yaml"]
-#elif MIN_VERSION_GLASGOW_HASKELL(8,6,3,0)
-stackYamlArg = ["--stack-yaml=stack-8.6.3.yaml"]
-#elif MIN_VERSION_GLASGOW_HASKELL(8,4,4,0)
-stackYamlArg = ["--stack-yaml=stack-8.4.4.yaml"]
-#elif MIN_VERSION_GLASGOW_HASKELL(8,4,3,0)
-stackYamlArg = ["--stack-yaml=stack-8.4.3.yaml" ]
-#elif MIN_VERSION_GLASGOW_HASKELL(8,2,2,0)
-stackYamlArg = ["--stack-yaml=stack-8.2.2.yaml" ]
-#else
-stackYamlArg = ["--stack-yaml=stack-8.0.2.yaml" ]
-#endif
 
-buildAndIndexTestPackage ::
-     FilePath -> IO (Either String (PackageInfo ModuleInfo))
+buildAndIndexTestPackage
+  :: FilePath -> IO (Either String (PackageInfo ModuleInfo))
 buildAndIndexTestPackage currentDir = do
   mbStackExecutable <- findExecutable "stack"
   case mbStackExecutable of
     Just stackExecutable -> do
-      let removeEndOfLine str
-            | null str = str
-            | otherwise = init str
+      let removeEndOfLine str | null str  = str
+                              | otherwise = init str
       (eitherDistDir :: Either IOError String) <-
-        try .
-        fmap removeEndOfLine .
-        readProcess stackExecutable (["path", "--dist-dir"] ++ stackYamlArg) $
-        ""
+        try
+        . fmap removeEndOfLine
+        . readProcess stackExecutable (["path", "--dist-dir"] ++ stackYamlArg)
+        $ ""
       case eitherDistDir of
         Right distDir -> do
           packageInfo <-
             let testPackageDirectoryPath = currentDir </> testPackageDir
-             in withCurrentDirectory testPackageDirectoryPath $ do
-                  _ <-
-                    readProcess
-                      stackExecutable
-                      (["build", "--test","--force-dirty"] ++ stackYamlArg)
-                      ""
+            in  withCurrentDirectory testPackageDirectoryPath $ do
+                  _ <- readProcess
+                    stackExecutable
+                    (["build", "--test", "--force-dirty"] ++ stackYamlArg)
+                    ""
                   runLoggingT
-                    (createPackageInfo
-                       testPackageDirectoryPath
-                       (Just distDir)
-                       HCE.BeforePreprocessing
-                       []
-                       [])
+                    (createPackageInfo testPackageDirectoryPath
+                                       (Just distDir)
+                                       HCE.BeforePreprocessing
+                                       []
+                                       []
+                    )
                     (\_ _ _ _ -> return ())
           return . Right $ packageInfo
         Left ex -> return . Left $ show ex
     Nothing ->
-      return . Left $
-      "Cannot find stack executable. Stack executable is required to build the test package."
+      return
+        . Left
+        $ "Cannot find stack executable. Stack executable is required to build the test package."
 
 sourceCodeTransformationSpec :: FilePath -> Spec
 sourceCodeTransformationSpec currentDir = do
   sourceCodeAfterPreprocessor <-
     runIO $ BS.readFile $ currentDir </> "test/data/FileAfterPreprocessor.hs"
-  let sourceCodeTransformation =
-        fst $
-        createSourceCodeTransformation
-          (HaskellModulePath "File.hs")
-          (TE.decodeUtf8 sourceCodeAfterPreprocessor)
-          (TE.decodeUtf8 sourceCodeAfterPreprocessor)
+  let sourceCodeTransformation = fst $ createSourceCodeTransformation
+        (HaskellModulePath "File.hs")
+        (TE.decodeUtf8 sourceCodeAfterPreprocessor)
+        (TE.decodeUtf8 sourceCodeAfterPreprocessor)
   describe "createSourceCodeTransformation" $ do
     it "returns valid list of pragmas" $ do
-      let pragmas =
-            S.fromList
-              [ LinePragma (HaskellFilePath "File1.hs") 8 1
-              , LinePragma (HaskellFilePath "File1.hs") 11 14
-              , LinePragma (HaskellFilePath "File2.hs") 12 1
-              , LinePragma (HaskellFilePath "File1.hs") 18 15
-              , LinePragma (HaskellFilePath "File.hs") 21 9
-              , LinePragma (HaskellFilePath "File.hs") 23 18
-              , LinePragma (HaskellFilePath "File3.hs") 26 1
-              , LinePragma (HaskellFilePath "File.hs") 30 21
-              ]
+      let pragmas = S.fromList
+            [ LinePragma (HaskellFilePath "File1.hs") 8  1
+            , LinePragma (HaskellFilePath "File1.hs") 11 14
+            , LinePragma (HaskellFilePath "File2.hs") 12 1
+            , LinePragma (HaskellFilePath "File1.hs") 18 15
+            , LinePragma (HaskellFilePath "File.hs")  21 9
+            , LinePragma (HaskellFilePath "File.hs")  23 18
+            , LinePragma (HaskellFilePath "File3.hs") 26 1
+            , LinePragma (HaskellFilePath "File.hs")  30 21
+            ]
       linePragmas sourceCodeTransformation `shouldBe` pragmas
-    it "returns valid file index" $
-      let index =
-            HM.fromList
-              [ ( HaskellFilePath {getHaskellFilePath = "File1.hs"}
-                , S.fromList
-                    [ FileLocation {lineStart = 1, lineEnd = 2, offset = 8}
-                    , FileLocation {lineStart = 15, lineEnd = 16, offset = 4}
-                    ])
-              , ( HaskellFilePath {getHaskellFilePath = "File2.hs"}
-                , S.fromList
-                    [FileLocation {lineStart = 1, lineEnd = 5, offset = 12}])
-              , ( HaskellFilePath {getHaskellFilePath = "File3.hs"}
-                , S.fromList
-                    [FileLocation {lineStart = 1, lineEnd = 3, offset = 26}])
-              , ( HaskellFilePath {getHaskellFilePath = "File.hs"}
-                , S.fromList
-                    [ FileLocation {lineStart = 1, lineEnd = 8, offset = 0}
-                    , FileLocation {lineStart = 9, lineEnd = 9, offset = 13}
-                    , FileLocation {lineStart = 18, lineEnd = 19, offset = 6}
-                    , FileLocation {lineStart = 21, lineEnd = 21, offset = 10}
-                    ])
-              ]
-       in fileIndex sourceCodeTransformation `shouldBe` index
+    it "returns valid file index"
+      $ let
+          index = HM.fromList
+            [ ( HaskellFilePath { getHaskellFilePath = "File1.hs" }
+              , S.fromList
+                [ FileLocation { lineStart = 1, lineEnd = 2, offset = 8 }
+                , FileLocation { lineStart = 15, lineEnd = 16, offset = 4 }
+                ]
+              )
+            , ( HaskellFilePath { getHaskellFilePath = "File2.hs" }
+              , S.fromList
+                [FileLocation { lineStart = 1, lineEnd = 5, offset = 12 }]
+              )
+            , ( HaskellFilePath { getHaskellFilePath = "File3.hs" }
+              , S.fromList
+                [FileLocation { lineStart = 1, lineEnd = 3, offset = 26 }]
+              )
+            , ( HaskellFilePath { getHaskellFilePath = "File.hs" }
+              , S.fromList
+                [ FileLocation { lineStart = 1, lineEnd = 8, offset = 0 }
+                , FileLocation { lineStart = 9, lineEnd = 9, offset = 13 }
+                , FileLocation { lineStart = 18, lineEnd = 19, offset = 6 }
+                , FileLocation { lineStart = 21, lineEnd = 21, offset = 10 }
+                ]
+              )
+            ]
+        in  fileIndex sourceCodeTransformation `shouldBe` index
   describe "fromOriginalLineNumber" $ do
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 1) (Right 1)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 4) (Right 4)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File1.hs", 1) (Right 9)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File1.hs", 2) (Right 10)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File2.hs", 1) (Right 13)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File2.hs", 3) (Right 15)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File2.hs", 5) (Right 17)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File1.hs", 15) (Right 19)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File1.hs", 16) (Right 20)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File3.hs", 1) (Right 27)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File3.hs", 2) (Right 28)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File3.hs", 3) (Right 29)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 9) (Right 22)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 18) (Right 24)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 19) (Right 25)
-    test fromOriginalLineNumber sourceCodeTransformation (HaskellFilePath "File.hs", 21) (Right 31)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 1)
+         (Right 1)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 4)
+         (Right 4)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File1.hs", 1)
+         (Right 9)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File1.hs", 2)
+         (Right 10)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File2.hs", 1)
+         (Right 13)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File2.hs", 3)
+         (Right 15)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File2.hs", 5)
+         (Right 17)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File1.hs", 15)
+         (Right 19)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File1.hs", 16)
+         (Right 20)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File3.hs", 1)
+         (Right 27)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File3.hs", 2)
+         (Right 28)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File3.hs", 3)
+         (Right 29)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 9)
+         (Right 22)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 18)
+         (Right 24)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 19)
+         (Right 25)
+    test fromOriginalLineNumber
+         sourceCodeTransformation
+         (HaskellFilePath "File.hs", 21)
+         (Right 31)
 
-test ::
-     forall a t t1. (Show t1, Show t, Show a, Eq a)
+test
+  :: forall a t t1
+   . (Show t1, Show t, Show a, Eq a)
   => (t1 -> t -> a)
   -> t1
   -> t
@@ -286,913 +318,858 @@ test fun arg1 arg2 result =
   it (show arg1 ++ " " ++ show arg2) $ fun arg1 arg2 `shouldBe` result
 
 tokenizeSpec :: Spec
-tokenizeSpec =
-  describe "tokenize" $ do
-    test tokenize "" ([] :: [((Int, Int), String)]) []
-    test
-      tokenize
-      "--comment"
-      ([] :: [((Int, Int), String)])
-      [("--comment", (1, 10), Nothing)]
-    test
-      tokenize
-      ("abcd" :: T.Text)
-      [((1, 5), "abcdIdentifier")]
-      [("abcd", (1, 5), Just "abcdIdentifier")]
-    test
-      tokenize
-      ("data Test" :: T.Text)
-      [((6, 10), "TestIdentifier")]
-      [("data ", (1, 6), Nothing), ("Test", (6, 10), Just "TestIdentifier")]
-    test
-      tokenize
-      ("abc = xyz" :: T.Text)
-      [((1, 4), "abcIdentifier"), ((7, 10), "xyzIdentifier")]
-      [ ("abc", (1, 4), Just "abcIdentifier")
-      , (" = ", (4, 7), Nothing)
-      , ("xyz", (7, 10), Just "xyzIdentifier")
-      ]
-    test
-      tokenize
-      ("abc = xyz --comment" :: T.Text)
-      [((1, 4), "abcIdentifier"), ((7, 10), "xyzIdentifier")]
-      [ ("abc", (1, 4), Just "abcIdentifier")
-      , (" = ", (4, 7), Nothing)
-      , ("xyz", (7, 10), Just "xyzIdentifier")
-      , (" --comment", (10, 20), Nothing)
-      ]
-    test
-      tokenize
-      ("   abc = xyz --comment" :: T.Text)
-      [((4, 7), "abcIdentifier"), ((10, 13), "xyzIdentifier")]
-      [ ("   ", (1, 4), Nothing)
-      , ("abc", (4, 7), Just "abcIdentifier")
-      , (" = ", (7, 10), Nothing)
-      , ("xyz", (10, 13), Just "xyzIdentifier")
-      , (" --comment", (13, 23), Nothing)
-      ]
+tokenizeSpec = describe "tokenize" $ do
+  test tokenize "" ([] :: [((Int, Int), String)]) []
+  test tokenize
+       "--comment"
+       ([] :: [((Int, Int), String)])
+       [("--comment", (1, 10), Nothing)]
+  test tokenize
+       ("abcd" :: T.Text)
+       [((1, 5), "abcdIdentifier")]
+       [("abcd", (1, 5), Just "abcdIdentifier")]
+  test tokenize
+       ("data Test" :: T.Text)
+       [((6, 10), "TestIdentifier")]
+       [("data ", (1, 6), Nothing), ("Test", (6, 10), Just "TestIdentifier")]
+  test
+    tokenize
+    ("abc = xyz" :: T.Text)
+    [((1, 4), "abcIdentifier"), ((7, 10), "xyzIdentifier")]
+    [ ("abc", (1, 4) , Just "abcIdentifier")
+    , (" = ", (4, 7) , Nothing)
+    , ("xyz", (7, 10), Just "xyzIdentifier")
+    ]
+  test
+    tokenize
+    ("abc = xyz --comment" :: T.Text)
+    [((1, 4), "abcIdentifier"), ((7, 10), "xyzIdentifier")]
+    [ ("abc"       , (1, 4)  , Just "abcIdentifier")
+    , (" = "       , (4, 7)  , Nothing)
+    , ("xyz"       , (7, 10) , Just "xyzIdentifier")
+    , (" --comment", (10, 20), Nothing)
+    ]
+  test
+    tokenize
+    ("   abc = xyz --comment" :: T.Text)
+    [((4, 7), "abcIdentifier"), ((10, 13), "xyzIdentifier")]
+    [ ("   "       , (1, 4)  , Nothing)
+    , ("abc"       , (4, 7)  , Just "abcIdentifier")
+    , (" = "       , (7, 10) , Nothing)
+    , ("xyz"       , (10, 13), Just "xyzIdentifier")
+    , (" --comment", (13, 23), Nothing)
+    ]
 
 removeOverlappingIntervalSpec :: Spec
-removeOverlappingIntervalSpec =
-  describe "removeOverlappingInterval" $ do
-    test removeOverlappingInterval [((1, 2), "a")] [] [((1, 2), "a")]
-    test
-      removeOverlappingInterval
-      [((3, 4), "b")]
-      [((1, 2), "a")]
-      [((1, 2), "a"), ((3, 4), "b")]
-    test
-      removeOverlappingInterval
-      [((2, 3), "b")]
-      [((1, 5), "a")]
-      [((2, 3), "b")]
-    test
-      removeOverlappingInterval
-      [((1, 5), "b")]
-      [((2, 3), "a")]
-      [((2, 3), "a")]
-    test
-      removeOverlappingInterval
-      [((1, 5), "b")]
-      [((2, 7), "a")]
-      [((1, 5), "b")]
-    test
-      removeOverlappingInterval
-      [((1, 3), "b")]
-      [((1, 3), "a")]
-      [((1, 3), "a")]
+removeOverlappingIntervalSpec = describe "removeOverlappingInterval" $ do
+  test removeOverlappingInterval [((1, 2), "a")] [] [((1, 2), "a")]
+  test removeOverlappingInterval
+       [((3, 4), "b")]
+       [((1, 2), "a")]
+       [((1, 2), "a"), ((3, 4), "b")]
+  test removeOverlappingInterval [((2, 3), "b")] [((1, 5), "a")] [((2, 3), "b")]
+  test removeOverlappingInterval [((1, 5), "b")] [((2, 3), "a")] [((2, 3), "a")]
+  test removeOverlappingInterval [((1, 5), "b")] [((2, 7), "a")] [((1, 5), "b")]
+  test removeOverlappingInterval [((1, 3), "b")] [((1, 3), "a")] [((1, 3), "a")]
 
 testDeclarations :: [Declaration]
 testDeclarations =
   [ Declaration
-      { sort = ValD
-      , name = "someFunc"
-      , declType =
-          Just
-            (Type
-               { components =
-                   [ TyCon {internalId = HCE.InternalId "0", name = "IO"}
-                   , Text " ()"
-                   ]
-               , componentsExpanded = Nothing
-               })
-      , isExported = True
-      , lineNumber = 9
-      }
+    { sort       = ValD
+    , name       = "someFunc"
+    , declType   = Just
+                     (Type
+                       { components = [ TyCon { internalId = HCE.InternalId "0"
+                                              , name       = "IO"
+                                              }
+                                      , Text " ()"
+                                      ]
+                       , componentsExpanded = Nothing
+                       }
+                     )
+    , isExported = True
+    , lineNumber = 9
+    }
   , Declaration
-      { sort = ValD
-      , name = "mkTest"
-      , declType =
-          Just
-            (Type
-               { components =
-                   [ TyCon {internalId = HCE.InternalId "9", name = "Int"}
-                   , Text " -> "
-                   , TyCon {internalId = HCE.InternalId "1", name = "Test"}
-                   ]
-               , componentsExpanded = Nothing
-               })
-      , isExported = False
-      , lineNumber = 13
-      }
+    { sort       = ValD
+    , name       = "mkTest"
+    , declType   = Just
+      (Type
+        { components         =
+          [ TyCon { internalId = HCE.InternalId "9", name = "Int" }
+          , Text " -> "
+          , TyCon { internalId = HCE.InternalId "1", name = "Test" }
+          ]
+        , componentsExpanded = Nothing
+        }
+      )
+    , isExported = False
+    , lineNumber = 13
+    }
   ]
 
-testExprInfoMap :: IVM.IntervalMap (Int,Int) HCE.ExpressionInfo
-testExprInfoMap =
-  IVM.fromList
-    [ ( IVM.OpenInterval (9, 12) (9, 31)
-      , ExpressionInfo
-          { description = "HsApp"
-          , exprType =
-              Just
-                (Type
-                   { components =
-                       [ TyCon {internalId = InternalId {getInternalId = "0"}, name = "IO"}
-                       , Text " ()"
-                       ]
-                   , componentsExpanded = Nothing
-                   })
-          })
-    , ( IVM.OpenInterval (13, 12) (13, 18)
-      , ExpressionInfo
-          { description = "HsApp"
-          , exprType =
-              Just
-                (Type
-                   { components =
-                       [ TyCon
-                           {internalId = InternalId {getInternalId = "1"}, name = "Test"}
-                       ]
-                   , componentsExpanded = Nothing
-                   })
-          })
-    ]
+testExprInfoMap :: IVM.IntervalMap (Int, Int) HCE.ExpressionInfo
+testExprInfoMap = IVM.fromList
+  [ ( IVM.OpenInterval (9, 12) (9, 31)
+    , ExpressionInfo
+      { description = "HsApp"
+      , exprType    = Just
+                        (Type
+                          { components         = [ TyCon
+                                                   { internalId = InternalId
+                                                                    { getInternalId = "0"
+                                                                    }
+                                                   , name       = "IO"
+                                                   }
+                                                 , Text " ()"
+                                                 ]
+                          , componentsExpanded = Nothing
+                          }
+                        )
+      }
+    )
+  , ( IVM.OpenInterval (13, 12) (13, 18)
+    , ExpressionInfo
+      { description = "HsApp"
+      , exprType    = Just
+        (Type
+          { components         =
+            [ TyCon { internalId = InternalId { getInternalId = "1" }
+                    , name       = "Test"
+                    }
+            ]
+          , componentsExpanded = Nothing
+          }
+        )
+      }
+    )
+  ]
 
 
 testIdOccMap :: IM.IntMap [((Int, Int), IdentifierOccurrence)]
-testIdOccMap =
-  IM.fromList
-    [ ( 2
-      , [ ( (7, 15)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "2"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "3"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "IE"
-              , sort = ValueId
-              })
-        ])
-    , ( 5
-      , [ ( (8, 13)
-          , IdentifierOccurrence
-              { internalId = Nothing
-              , internalIdFromRenamedSource = Nothing
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "ImportDecl"
-              , sort =
-                  ModuleId
-                    (ExactLocation
-                       { packageId =
-                           PackageId
-                             { name = "test-package"
-                             , version = makeVersion [0, 1, 0, 0]
-                             }
-                       , modulePath =
-                           HaskellModulePath
-                             {getHaskellModulePath = "src/Types.hs"}
-                       , moduleName =
-                           HaskellModuleName {getHaskellModuleName = "Types"}
-                       , startLine = 1
-                       , endLine = 1
-                       , startColumn = 1
-                       , endColumn = 1
-                       })
-              })
-        , ( (14, 18)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "1"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "1"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "IE"
-              , sort = TypeId
-              })
-        ])
-    , ( 8
-      , [ ( (1, 9)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "2"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "3"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "TypeSig"
-              , sort = ValueId
-              })
-        , ( (13, 15)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "0"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "0"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsTyVar"
-              , sort = TypeId
-              })
-        , ( (16, 18)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "4"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "4"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsTupleTy"
-              , sort = TypeId
-              })
-        ])
-    , ( 9
-      , [ ( (1, 9)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "2"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "3"})
-              , isBinder = True
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "Match"
-              , sort = ValueId
-              })
-        , ( (12, 20)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "5"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "5"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsVar"
-              , sort = ValueId
-              })
-        , ( (21, 31)
-          , IdentifierOccurrence
-              { internalId = Nothing
-              , internalIdFromRenamedSource = Nothing
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType =
-                  Just
-                    (Type
-                       { components =
-                           [ Text "["
-                           , TyCon
-                               { internalId = InternalId {getInternalId = "6"}
-                               , name = "Char"
-                               }
-                           , Text "]"
-                           ]
-                       , componentsExpanded = Nothing
-                       })
-              , typeArguments = Nothing
-              , description = "HsLit"
-              , sort = ValueId
-              })
-        ])
-    , ( 12
-      , [ ( (1, 7)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "7"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "8"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "TypeSig"
-              , sort = ValueId
-              })
-        , ( (11, 14)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "9"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "9"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsTyVar"
-              , sort = TypeId
-              })
-        , ( (18, 22)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "1"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "1"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsTyVar"
-              , sort = TypeId
-              })
-        ])
-    , ( 13
-      , [ ( (1, 7)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "7"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "8"})
-              , isBinder = True
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "Match"
-              , sort = ValueId
-              })
-        , ( (8, 9)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "10"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "11"})
-              , isBinder = True
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "VarPat"
-              , sort = ValueId
-              })
-        , ( (12, 16)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "12"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "13"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsVar"
-              , sort = ValueId
-              })
-        , ( (17, 18)
-          , IdentifierOccurrence
-              { internalId = Just (InternalId {getInternalId = "10"})
-              , internalIdFromRenamedSource =
-                  Just (InternalId {getInternalId = "11"})
-              , isBinder = False
-              , instanceResolution = Nothing
-              , idOccType = Nothing
-              , typeArguments = Nothing
-              , description = "HsVar"
-              , sort = ValueId
-              })
-        ])
-    ]
+testIdOccMap = IM.fromList
+  [ ( 2
+    , [ ( (7, 15)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "2" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "3" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "IE"
+          , sort                        = ValueId
+          }
+        )
+      ]
+    )
+  , ( 5
+    , [ ( (8, 13)
+        , IdentifierOccurrence
+          { internalId                  = Nothing
+          , internalIdFromRenamedSource = Nothing
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "ImportDecl"
+          , sort                        = ModuleId
+            (ExactLocation
+              { packageId   = PackageId { name    = "test-package"
+                                        , version = makeVersion [0, 1, 0, 0]
+                                        }
+              , modulePath  = HaskellModulePath
+                                { getHaskellModulePath = "src/Types.hs"
+                                }
+              , moduleName  = HaskellModuleName { getHaskellModuleName = "Types"
+                                                }
+              , startLine   = 1
+              , endLine     = 1
+              , startColumn = 1
+              , endColumn   = 1
+              }
+            )
+          }
+        )
+      , ( (14, 18)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "1" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "1" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "IE"
+          , sort                        = TypeId
+          }
+        )
+      ]
+    )
+  , ( 8
+    , [ ( (1, 9)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "2" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "3" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "TypeSig"
+          , sort                        = ValueId
+          }
+        )
+      , ( (13, 15)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "0" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "0" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsTyVar"
+          , sort                        = TypeId
+          }
+        )
+      , ( (16, 18)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "4" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "4" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsTupleTy"
+          , sort                        = TypeId
+          }
+        )
+      ]
+    )
+  , ( 9
+    , [ ( (1, 9)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "2" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "3" })
+          , isBinder                    = True
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "Match"
+          , sort                        = ValueId
+          }
+        )
+      , ( (12, 20)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "5" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "5" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsVar"
+          , sort                        = ValueId
+          }
+        )
+      , ( (21, 31)
+        , IdentifierOccurrence
+          { internalId                  = Nothing
+          , internalIdFromRenamedSource = Nothing
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Just
+            (Type
+              { components         = [ Text "["
+                                     , TyCon
+                                       { internalId = InternalId { getInternalId = "6" }
+                                       , name = "Char"
+                                       }
+                                     , Text "]"
+                                     ]
+              , componentsExpanded = Nothing
+              }
+            )
+          , typeArguments               = Nothing
+          , description                 = "HsLit"
+          , sort                        = ValueId
+          }
+        )
+      ]
+    )
+  , ( 12
+    , [ ( (1, 7)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "7" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "8" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "TypeSig"
+          , sort                        = ValueId
+          }
+        )
+      , ( (11, 14)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "9" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "9" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsTyVar"
+          , sort                        = TypeId
+          }
+        )
+      , ( (18, 22)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "1" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "1" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsTyVar"
+          , sort                        = TypeId
+          }
+        )
+      ]
+    )
+  , ( 13
+    , [ ( (1, 7)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "7" })
+          , internalIdFromRenamedSource = Just
+                                            (InternalId { getInternalId = "8" })
+          , isBinder                    = True
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "Match"
+          , sort                        = ValueId
+          }
+        )
+      , ( (8, 9)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "10" })
+          , internalIdFromRenamedSource = Just
+            (InternalId { getInternalId = "11" })
+          , isBinder                    = True
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "VarPat"
+          , sort                        = ValueId
+          }
+        )
+      , ( (12, 16)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "12" })
+          , internalIdFromRenamedSource = Just
+            (InternalId { getInternalId = "13" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsVar"
+          , sort                        = ValueId
+          }
+        )
+      , ( (17, 18)
+        , IdentifierOccurrence
+          { internalId = Just (InternalId { getInternalId = "10" })
+          , internalIdFromRenamedSource = Just
+            (InternalId { getInternalId = "11" })
+          , isBinder                    = False
+          , instanceResolution          = Nothing
+          , idOccType                   = Nothing
+          , typeArguments               = Nothing
+          , description                 = "HsVar"
+          , sort                        = ValueId
+          }
+        )
+      ]
+    )
+  ]
 
 testIdInfoMap :: HM.HashMap InternalId IdentifierInfo
-testIdInfoMap =
-  HM.fromList
-    [ ( InternalId {getInternalId = "7"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "mkTest"}
-          , demangledOccName = "mkTest"
-          , nameSpace = VarName
-          , locationInfo =
-              ExactLocation
-                { packageId =
-                    PackageId
-                      { name = "test-package"
-                      , version = makeVersion [0, 1, 0, 0]
-                      }
-                , modulePath =
-                    HaskellModulePath {getHaskellModulePath = "src/Lib.hs"}
-                , moduleName = HaskellModuleName {getHaskellModuleName = "Lib"}
-                , startLine = 13
-                , endLine = 13
-                , startColumn = 1
-                , endColumn = 7
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "9"}
-                        , name = "Int"
-                        }
-                    , Text " -> "
-                    , TyCon
-                        { internalId = InternalId {getInternalId = "1"}
-                        , name = "Test"
-                        }
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Just VanillaId
-          , doc = Just "<p><span>mkTest documentation</span></p>"
-          , internalId = InternalId {getInternalId = "7"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "test-package-0.1.0.0|Lib|Val|mkTest"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "14"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "TYPE"}
-          , demangledOccName = "TYPE"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Prim"}
-                , entity = Typ
-                , name = "TYPE"
-                , haddockAnchorId = Just "TYPE"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "15"}
-                        , name = "RuntimeRep"
-                        }
-                    , Text " -> *"
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "14"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Prim|Typ|TYPE"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "0"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "IO"}
-          , demangledOccName = "IO"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Types"}
-                , entity = Typ
-                , name = "IO"
-                , haddockAnchorId = Just "IO"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "* -> *"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "0"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|IO"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "12"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "Test"}
-          , demangledOccName = "Test"
-          , nameSpace = DataName
-          , locationInfo =
-              ExactLocation
-                { packageId =
-                    PackageId
-                      { name = "test-package"
-                      , version = makeVersion [0, 1, 0, 0]
-                      }
-                , modulePath =
-                    HaskellModulePath {getHaskellModulePath = "src/Types.hs"}
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "Types"}
-                , startLine = 5
-                , endLine = 5
-                , startColumn = 13
-                , endColumn = 21
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "9"}
-                        , name = "Int"
-                        }
-                    , Text " -> "
-                    , TyCon
-                        { internalId = InternalId {getInternalId = "1"}
-                        , name = "Test"
-                        }
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Just DataConWorkId
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "12"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "test-package-0.1.0.0|Types|Val|Test"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "17"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "[]"}
-          , demangledOccName = "[]"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Types"}
-                , entity = Typ
-                , name = "[]"
-                , haddockAnchorId = Just "-91--93-"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "* -> *"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "17"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|[]"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "1"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "Test"}
-          , demangledOccName = "Test"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ExactLocation
-                { packageId =
-                    PackageId
-                      { name = "test-package"
-                      , version = makeVersion [0, 1, 0, 0]
-                      }
-                , modulePath =
-                    HaskellModulePath {getHaskellModulePath = "src/Types.hs"}
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "Types"}
-                , startLine = 5
-                , endLine = 5
-                , startColumn = 1
-                , endColumn = 21
-                }
-          , idType =
-              Type {components = [Text "*"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "1"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "test-package-0.1.0.0|Types|Typ|Test"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "18"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "LiftedRep"}
-          , demangledOccName = "LiftedRep"
-          , nameSpace = DataName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Types"}
-                , entity = Val
-                , name = "LiftedRep"
-                , haddockAnchorId = Just "LiftedRep"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "15"}
-                        , name = "RuntimeRep"
-                        }
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "18"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Val|LiftedRep"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "4"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "()"}
-          , demangledOccName = "()"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Tuple"}
-                , entity = Typ
-                , name = "()"
-                , haddockAnchorId = Just "-40--41-"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "*"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "4"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Tuple|Typ|()"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "16"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "String"}
-          , demangledOccName = "String"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "base"
-                      , version = makeVersion [4, 10, 1, 0]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Base"}
-                , entity = Typ
-                , name = "String"
-                , haddockAnchorId = Just "String"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "*"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "16"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "base-4.10.1.0|GHC.Base|Typ|String"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "2"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "someFunc"}
-          , demangledOccName = "someFunc"
-          , nameSpace = VarName
-          , locationInfo =
-              ExactLocation
-                { packageId =
-                    PackageId
-                      { name = "test-package"
-                      , version = makeVersion [0, 1, 0, 0]
-                      }
-                , modulePath =
-                    HaskellModulePath {getHaskellModulePath = "src/Lib.hs"}
-                , moduleName = HaskellModuleName {getHaskellModuleName = "Lib"}
-                , startLine = 9
-                , endLine = 9
-                , startColumn = 1
-                , endColumn = 9
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "0"}
-                        , name = "IO"
-                        }
-                    , Text " ()"
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Just VanillaId
-          , doc = Just "<p><span>someFunc documentation</span></p>"
-          , internalId = InternalId {getInternalId = "2"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "test-package-0.1.0.0|Lib|Val|someFunc"})
-          , isExported = True
-          })
-    , ( InternalId {getInternalId = "5"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "putStrLn"}
-          , demangledOccName = "putStrLn"
-          , nameSpace = VarName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "base"
-                      , version = makeVersion [4, 10, 1, 0]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "System.IO"}
-                , entity = Val
-                , name = "putStrLn"
-                , haddockAnchorId = Just "putStrLn"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "16"}
-                        , name = "String"
-                        }
-                    , Text " -> "
-                    , TyCon
-                        { internalId = InternalId {getInternalId = "0"}
-                        , name = "IO"
-                        }
-                    , Text " ()"
-                    ]
-                , componentsExpanded =
-                    Just
-                      [ Text "["
-                      , TyCon
-                          { internalId = InternalId {getInternalId = "6"}
-                          , name = "Char"
-                          }
-                      , Text "] -> "
-                      , TyCon
-                          { internalId = InternalId {getInternalId = "0"}
-                          , name = "IO"
-                          }
-                      , Text " ()"
-                      ]
-                }
-          , details = Just VanillaId
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "5"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "base-4.10.1.0|System.IO|Val|putStrLn"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "6"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "Char"}
-          , demangledOccName = "Char"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Types"}
-                , entity = Typ
-                , name = "Char"
-                , haddockAnchorId = Just "Char"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "*"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "6"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|Char"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "9"}
-      , IdentifierInfo
-          { sort = External
-          , occName = OccName {getOccName = "Int"}
-          , demangledOccName = "Int"
-          , nameSpace = TcClsName
-          , locationInfo =
-              ApproximateLocation
-                { packageId =
-                    PackageId
-                      { name = "ghc-prim"
-                      , version = makeVersion [0, 5, 1, 1]
-                      }
-                , moduleName =
-                    HaskellModuleName {getHaskellModuleName = "GHC.Types"}
-                , entity = Typ
-                , name = "Int"
-                , haddockAnchorId = Just "Int"
-                , componentId = ComponentId {getComponentId = "lib"}
-                }
-          , idType =
-              Type {components = [Text "*"], componentsExpanded = Nothing}
-          , details = Nothing
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "9"}
-          , externalId =
-              Just
-                (ExternalId
-                   {getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|Int"})
-          , isExported = False
-          })
-    , ( InternalId {getInternalId = "10"}
-      , IdentifierInfo
-          { sort = Internal
-          , occName = OccName {getOccName = "i"}
-          , demangledOccName = "i"
-          , nameSpace = VarName
-          , locationInfo =
-              ExactLocation
-                { packageId =
-                    PackageId
-                      { name = "test-package"
-                      , version = makeVersion [0, 1, 0, 0]
-                      }
-                , modulePath =
-                    HaskellModulePath {getHaskellModulePath = "src/Lib.hs"}
-                , moduleName = HaskellModuleName {getHaskellModuleName = ""}
-                , startLine = 13
-                , endLine = 13
-                , startColumn = 8
-                , endColumn = 9
-                }
-          , idType =
-              Type
-                { components =
-                    [ TyCon
-                        { internalId = InternalId {getInternalId = "9"}
-                        , name = "Int"
-                        }
-                    ]
-                , componentsExpanded = Nothing
-                }
-          , details = Just VanillaId
-          , doc = Nothing
-          , internalId = InternalId {getInternalId = "10"}
-          , externalId = Nothing
-          , isExported = False
-          })
-    ]
-
-
+testIdInfoMap = HM.fromList
+  [ ( InternalId { getInternalId = "7" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "mkTest" }
+      , demangledOccName = "mkTest"
+      , nameSpace        = VarName
+      , locationInfo     = ExactLocation
+        { packageId   = PackageId { name    = "test-package"
+                                  , version = makeVersion [0, 1, 0, 0]
+                                  }
+        , modulePath = HaskellModulePath { getHaskellModulePath = "src/Lib.hs" }
+        , moduleName  = HaskellModuleName { getHaskellModuleName = "Lib" }
+        , startLine   = 13
+        , endLine     = 13
+        , startColumn = 1
+        , endColumn   = 7
+        }
+      , idType           = Type
+        { components         =
+          [ TyCon { internalId = InternalId { getInternalId = "9" }
+                  , name       = "Int"
+                  }
+          , Text " -> "
+          , TyCon { internalId = InternalId { getInternalId = "1" }
+                  , name       = "Test"
+                  }
+          ]
+        , componentsExpanded = Nothing
+        }
+      , details          = Just VanillaId
+      , doc              = Just "<p><span>mkTest documentation</span></p>"
+      , internalId       = InternalId { getInternalId = "7" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "test-package-0.1.0.0|Lib|Val|mkTest" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "14" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "TYPE" }
+      , demangledOccName = "TYPE"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Prim"
+                                                   }
+                             , entity          = Typ
+                             , name            = "TYPE"
+                             , haddockAnchorId = Just "TYPE"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType           = Type
+                             { components         = [ TyCon
+                                                      { internalId = InternalId
+                                                                       { getInternalId = "15"
+                                                                       }
+                                                      , name = "RuntimeRep"
+                                                      }
+                                                    , Text " -> *"
+                                                    ]
+                             , componentsExpanded = Nothing
+                             }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "14" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Prim|Typ|TYPE" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "0" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "IO" }
+      , demangledOccName = "IO"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Types"
+                                                   }
+                             , entity          = Typ
+                             , name            = "IO"
+                             , haddockAnchorId = Just "IO"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType           = Type { components         = [Text "* -> *"]
+                                , componentsExpanded = Nothing
+                                }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "0" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|IO" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "12" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "Test" }
+      , demangledOccName = "Test"
+      , nameSpace        = DataName
+      , locationInfo     = ExactLocation
+        { packageId   = PackageId { name    = "test-package"
+                                  , version = makeVersion [0, 1, 0, 0]
+                                  }
+        , modulePath = HaskellModulePath { getHaskellModulePath = "src/Types.hs"
+                                         }
+        , moduleName  = HaskellModuleName { getHaskellModuleName = "Types" }
+        , startLine   = 5
+        , endLine     = 5
+        , startColumn = 13
+        , endColumn   = 21
+        }
+      , idType           = Type
+        { components         =
+          [ TyCon { internalId = InternalId { getInternalId = "9" }
+                  , name       = "Int"
+                  }
+          , Text " -> "
+          , TyCon { internalId = InternalId { getInternalId = "1" }
+                  , name       = "Test"
+                  }
+          ]
+        , componentsExpanded = Nothing
+        }
+      , details          = Just DataConWorkId
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "12" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "test-package-0.1.0.0|Types|Val|Test" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "17" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "[]" }
+      , demangledOccName = "[]"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Types"
+                                                   }
+                             , entity          = Typ
+                             , name            = "[]"
+                             , haddockAnchorId = Just "-91--93-"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType           = Type { components         = [Text "* -> *"]
+                                , componentsExpanded = Nothing
+                                }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "17" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|[]" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "1" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "Test" }
+      , demangledOccName = "Test"
+      , nameSpace        = TcClsName
+      , locationInfo     = ExactLocation
+        { packageId   = PackageId { name    = "test-package"
+                                  , version = makeVersion [0, 1, 0, 0]
+                                  }
+        , modulePath = HaskellModulePath { getHaskellModulePath = "src/Types.hs"
+                                         }
+        , moduleName  = HaskellModuleName { getHaskellModuleName = "Types" }
+        , startLine   = 5
+        , endLine     = 5
+        , startColumn = 1
+        , endColumn   = 21
+        }
+      , idType = Type { components = [Text "*"], componentsExpanded = Nothing }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "1" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "test-package-0.1.0.0|Types|Typ|Test" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "18" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "LiftedRep" }
+      , demangledOccName = "LiftedRep"
+      , nameSpace        = DataName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Types"
+                                                   }
+                             , entity          = Val
+                             , name            = "LiftedRep"
+                             , haddockAnchorId = Just "LiftedRep"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType           = Type
+                             { components         = [ TyCon
+                                                        { internalId = InternalId
+                                                                         { getInternalId = "15"
+                                                                         }
+                                                        , name = "RuntimeRep"
+                                                        }
+                                                    ]
+                             , componentsExpanded = Nothing
+                             }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "18" }
+      , externalId       =
+        Just
+          (ExternalId
+            { getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Val|LiftedRep"
+            }
+          )
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "4" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "()" }
+      , demangledOccName = "()"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Tuple"
+                                                   }
+                             , entity          = Typ
+                             , name            = "()"
+                             , haddockAnchorId = Just "-40--41-"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType = Type { components = [Text "*"], componentsExpanded = Nothing }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "4" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Tuple|Typ|()" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "16" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "String" }
+      , demangledOccName = "String"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "base"
+                                                   , version = makeVersion [4, 10, 1, 0]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Base"
+                                                   }
+                             , entity          = Typ
+                             , name            = "String"
+                             , haddockAnchorId = Just "String"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType = Type { components = [Text "*"], componentsExpanded = Nothing }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "16" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "base-4.10.1.0|GHC.Base|Typ|String" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "2" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "someFunc" }
+      , demangledOccName = "someFunc"
+      , nameSpace        = VarName
+      , locationInfo     = ExactLocation
+        { packageId   = PackageId { name    = "test-package"
+                                  , version = makeVersion [0, 1, 0, 0]
+                                  }
+        , modulePath = HaskellModulePath { getHaskellModulePath = "src/Lib.hs" }
+        , moduleName  = HaskellModuleName { getHaskellModuleName = "Lib" }
+        , startLine   = 9
+        , endLine     = 9
+        , startColumn = 1
+        , endColumn   = 9
+        }
+      , idType           = Type
+                             { components         = [ TyCon
+                                                      { internalId = InternalId
+                                                                       { getInternalId = "0"
+                                                                       }
+                                                      , name       = "IO"
+                                                      }
+                                                    , Text " ()"
+                                                    ]
+                             , componentsExpanded = Nothing
+                             }
+      , details          = Just VanillaId
+      , doc              = Just "<p><span>someFunc documentation</span></p>"
+      , internalId       = InternalId { getInternalId = "2" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "test-package-0.1.0.0|Lib|Val|someFunc" })
+      , isExported       = True
+      }
+    )
+  , ( InternalId { getInternalId = "5" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "putStrLn" }
+      , demangledOccName = "putStrLn"
+      , nameSpace        = VarName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "base"
+                                                   , version = makeVersion [4, 10, 1, 0]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "System.IO"
+                                                   }
+                             , entity          = Val
+                             , name            = "putStrLn"
+                             , haddockAnchorId = Just "putStrLn"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType           = Type
+        { components         =
+          [ TyCon { internalId = InternalId { getInternalId = "16" }
+                  , name       = "String"
+                  }
+          , Text " -> "
+          , TyCon { internalId = InternalId { getInternalId = "0" }
+                  , name       = "IO"
+                  }
+          , Text " ()"
+          ]
+        , componentsExpanded = Just
+          [ Text "["
+          , TyCon { internalId = InternalId { getInternalId = "6" }
+                  , name       = "Char"
+                  }
+          , Text "] -> "
+          , TyCon { internalId = InternalId { getInternalId = "0" }
+                  , name       = "IO"
+                  }
+          , Text " ()"
+          ]
+        }
+      , details          = Just VanillaId
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "5" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "base-4.10.1.0|System.IO|Val|putStrLn" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "6" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "Char" }
+      , demangledOccName = "Char"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Types"
+                                                   }
+                             , entity          = Typ
+                             , name            = "Char"
+                             , haddockAnchorId = Just "Char"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType = Type { components = [Text "*"], componentsExpanded = Nothing }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "6" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|Char" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "9" }
+    , IdentifierInfo
+      { sort             = External
+      , occName          = OccName { getOccName = "Int" }
+      , demangledOccName = "Int"
+      , nameSpace        = TcClsName
+      , locationInfo     = ApproximateLocation
+                             { packageId       = PackageId
+                                                   { name = "ghc-prim"
+                                                   , version = makeVersion [0, 5, 1, 1]
+                                                   }
+                             , moduleName      = HaskellModuleName
+                                                   { getHaskellModuleName = "GHC.Types"
+                                                   }
+                             , entity          = Typ
+                             , name            = "Int"
+                             , haddockAnchorId = Just "Int"
+                             , componentId = ComponentId { getComponentId = "lib" }
+                             }
+      , idType = Type { components = [Text "*"], componentsExpanded = Nothing }
+      , details          = Nothing
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "9" }
+      , externalId       = Just
+        (ExternalId { getExternalId = "ghc-prim-0.5.1.1|GHC.Types|Typ|Int" })
+      , isExported       = False
+      }
+    )
+  , ( InternalId { getInternalId = "10" }
+    , IdentifierInfo
+      { sort             = Internal
+      , occName          = OccName { getOccName = "i" }
+      , demangledOccName = "i"
+      , nameSpace        = VarName
+      , locationInfo     = ExactLocation
+        { packageId   = PackageId { name    = "test-package"
+                                  , version = makeVersion [0, 1, 0, 0]
+                                  }
+        , modulePath = HaskellModulePath { getHaskellModulePath = "src/Lib.hs" }
+        , moduleName  = HaskellModuleName { getHaskellModuleName = "" }
+        , startLine   = 13
+        , endLine     = 13
+        , startColumn = 8
+        , endColumn   = 9
+        }
+      , idType           = Type
+        { components = [ TyCon { internalId = InternalId { getInternalId = "9" }
+                               , name       = "Int"
+                               }
+                       ]
+        , componentsExpanded = Nothing
+        }
+      , details          = Just VanillaId
+      , doc              = Nothing
+      , internalId       = InternalId { getInternalId = "10" }
+      , externalId       = Nothing
+      , isExported       = False
+      }
+    )
+  ]