-- | A 'DepNode' is a direct translation of a 'ModuleGraphNode' that

 -- can be serialised to a Makefile or json lines format.

 data DepNode =

   -- ^ A dependency node of a home module with its dependencies

 -- | A home module node.

 -- Everything we know about home modules that can be serialised.

     -- ^ 'UnitId' of the 'HomeUnitEnv' this home module belongs to.

     -- ^ Optional package name, used for @-XPackageImports@.

     -- ^ 'Module' of this home module with 'IsBootInterface' information.

     -- ^ Where is the source for this home module located.

     -- ^ Where is the object file for this home module located if it exists.

     -- ^ Where is the interface file for this home module located if it exists.

     -- ^ Is there a preprocessor that needs to be run for this module before compilation.

     -- ^ When serialising this home module, should we include external package dependencies

     -- (such as importing @Data.List@ from @base@) in the output?

     }

 -- | Preprocessor that needs to be run before a module can be compiled.

 data PreprocessingNode = PreprocessingNode

   -- ^ The preprocessor.

   }

 -- | A dependency edge on another module, or cpp path.

     -- as the 'DepModuleNode'.

     }

   | DepCpp

     { dep_path :: OsPath

     -- ^ Path to the @#include@d path.

     }

   = return Nothing

 processDeps hsc_env0 excl_mods (AcyclicSCC (ModuleNode _ (ModuleNodeCompile node))) = do

   let

     find_deps imps = do

       cpp_deps <- find_cpp_deps

   if null missing_dep_errs

     then do

     else do

       let sec = initSourceErrorContext dflags

       throwErrors sec (mkMessages (listToBag missing_dep_errs))

     -- separate dependencies and options.

     -- Thus, we need to set the active unit id to the one of the module we are processing.

     local_hsc_env = hscSetActiveUnitId (ms_unitid node) hsc_env0

     dflags = ms_hspp_opts node

     src_file = msHsFileOsPath node

         }

     preprocessor = do

         }

     -- Emit a dependency for each CPP import

     -- fails to parse, which may not be desirable (see #16616).

     find_cpp_deps :: IO [Dep]

     find_cpp_deps =

         then do

           session <- Session <$> newIORef local_hsc_env

           parsedMod <- reflectGhc (GHC.parseModule node) session

     mod_name = ui_mod_name imp

     is_boot  = ui_boot imp

 -----------------------------------------------------------------

 --

 --              beginMkDependHs

   Handle ->

   [OsString] ->

   -- ^ Suffixes

   [Dep] ->

   IO ()

 writeDependencies root hdl suffixes node deps =

     -- Emit std dependency of the object(s) on the source file

     -- Something like       A.o : A.hs

     -- add dependency between objects and their corresponding .hi-boot

     -- files if the module has a corresponding .hs-boot file (#14482)

       NotBoot -> []

     -- Add one dependency for each suffix;

     --              A.x_o : B.x_hi

     import_dep = \case

       DepHi {dep_path, dep_local}

         -> [([obj], hi) | (obj, hi) <- zip obj_files (suffixed dep_path)]

         | otherwise

     write (from, to) = writeDependency root hdl from to

     suffixed f = insertSuffixes f suffixes

 -----------------------------

 writeDependency :: OsPath -> Handle -> [OsPath] -> OsPath -> IO ()

   , source :: OsPath

   , imports :: ImportDeps

   , cpp :: Set.Set OsPath

   }

 addImport :: ImportDep -> HomeUnitDep -> HomeUnitDep

         , mkPair      "imports"      (importsObj imports)

         , omitIfNull  "package-name" (maybe JSNull JSString packageName)

         , mkPair      "source"       (JSString . showOsPath $ normalise source)

         ]

    where

     moduleKey :: Module -> String

         SpliceLevel -> "splice"

         QuoteLevel -> "quote"

     array values render = JSArray (fmap render (Set.toList values))

     omitIfDefault :: String -> a -> (a -> Bool) -> (a -> JsonDoc) -> [(String, JsonDoc)]

     omitIfDefault k v p toJson

         Set.union e0 extUnits

     }

   extUnits <- readJson deps_json

   let newExtUnits = Set.difference extUnitsDeps (externalDeps extUnits)

   -- Write new external unit deps before the module that uses them

     initial_node_data =

       HomeUnitDep

         , cpp = Set.empty

         , imports = ImportDeps Map.empty

         }

         | dep_local

         -> (extDeps, addImport (mkImportDep dep_mod dep_level dep_boot) node_data)

         , Just unit <- dep_unit

         , let PackageName nameFS = unitPackageName unit

               name = unpackFS nameFS