let (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

         implicit_prelude = xopt LangExt.ImplicitPrelude dflags

         rn_pkg_qual = renameRawPkgQual (hsc_unit_env hsc_env) modname

         convImport (L _ i) = (convImportLevel (ideclLevelSpec i), rn_pkg_qual (ideclPkgQual i), reLoc $ ideclName i)

     extra_sig_imports <- liftIO $ findExtraSigImports hsc_env hsc_src modname

     (implicit_sigs, inst_deps) <- liftIO $ implicitRequirementsShallow hsc_env normal_imports

     -- So that Finder can find it, even though it doesn't exist...

 data XImportDeclPass = XImportDeclPass

     { ideclAnn        :: EpAnn EpAnnImportDecl

     , ideclSourceText :: SourceText -- Note [Pragma source text] in "GHC.Types.SourceText"

     }

     deriving (Data)

 GHC generates an `ImportDecl` to represent the invisible `import Prelude`

 that appears in any file that omits `import Prelude`, setting

 this field to indicate that the import doesn't appear in the

 -}

 type instance XXImportDecl  (GhcPass _) = DataConCantHappen

       where

         pp_implicit ext =

             let implicit = case ghcPass @p of

                             GhcTc -> dataConCantHappen ext

             in if implicit then text "(implicit)"

                            else empty

     modName <- toHie (IEC Export <$> modName)

     tasts <- toHie $ fmap (BC RegularBind ModuleScope) ts

     rasts <- processGrp hsGrp

     exps <- toHie $ fmap (map $ IEC Export . fst) exports

     docs <- toHie docs

     -- Add Instance bindings

                 mod = mb_mod `orElse` L (noAnnSrcSpan main_loc) mAIN_NAME

                 (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

                 convImport (L _ (i :: ImportDecl GhcPs)) = (convImportLevel (ideclLevelSpec i), ideclPkgQual i, reLoc $ ideclName i)

                 convImport_src (L _ (i :: ImportDecl GhcPs)) = (reLoc $ ideclName i)

               in

               return (map convImport_src src_idecls

                      , reLoc mod)

         = L loc $ ImportDecl { ideclExt       = XImportDeclPass

                                                     { ideclAnn = noAnn

                                                     , ideclSourceText = NoSourceText

                                                     },

                                 ideclName      = L loc pRELUDE_NAME,

                                 ideclPkgQual   = NoRawPkgQual,

                                      , ideclSafe = mod_safe

                                      , ideclLevelSpec = import_level

                                      , ideclQualified = qual_style

                                      , ideclAs = as_mod, ideclImportList = imp_details }), import_reason)

   = setSrcSpanA loc $ do

 warnUnusedImportDecls :: TcGblEnv -> HscSource -> RnM ()

 warnUnusedImportDecls gbl_env hsc_src

   = do { uses <- readMutVar (tcg_used_gres gbl_env)

              rdr_env = tcg_rdr_env gbl_env

        ; traceRn "warnUnusedImportDecls" $

                        (vcat [ text "Uses:" <+> ppr uses

        ; whenGOptM Opt_D_dump_minimal_imports $

 findImportUsage :: [LImportDecl GhcRn]

                 -> [GlobalRdrElt]

 Note [Printing minimal imports]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   * We do *not* change the 'qualified' or 'as' parts!

 printMinimalImports :: HscSource -> [ImportDeclUsage] -> RnM ()

 -- See Note [Printing minimal imports]

 printMinimalImports hsc_src imports_w_usage

        ; this_mod <- getModule

        ; dflags   <- getDynFlags

        ; liftIO $ withFile (mkFilename dflags this_mod) WriteMode $ \h ->

     -- Less means better

     -- Unqualified always wins over qualified; then

     -- import-all wins over import-some; then

     -- earlier declaration wins over later

     best (ImpSpec { is_item = item1, is_decl = d1 })

          (ImpSpec { is_item = item2, is_decl = d2 })

         SrcLoc.leftmost_smallest (is_dloc d1) (is_dloc d2)

     best_item :: ImpItemSpec -> ImpItemSpec -> Ordering

               (ImpSome { is_explicit = e2 }) = e1 `compare` e2

      -- False < True, so if e1 is explicit and e2 is not, we get GT

 {- Note [Choosing the best import declaration]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 When reporting unused import declarations we use the following rules.

    let prelude_import =

          case simpleImportDecl preludeModuleName of

            -- Set to True because Prelude is implicitly imported.

    empty_cache <- liftIO newIfaceCache

    startGHCi (runGHCi srcs maybe_exprs)

         GHCiState{ progname           = default_progname,