    -- | This is the syntax for bkp files which are parsed in 'ghc --backpack'
    -- mode.  This syntax is used purely for testing purposes.

    module GHC.Driver.Backpack.Syntax (
        -- * Backpack abstract syntax
        HsUnitId(..),
        LHsUnitId,
        HsModuleSubst,
        LHsModuleSubst,
        HsModuleId(..),
        LHsModuleId,
        HsComponentId(..),
        LHsUnit, HsUnit(..),
        LHsUnitDecl, HsUnitDecl(..),
        IncludeDecl(..),
        LRenaming, Renaming(..),
        ) where

    import GHC.Prelude

    import GHC.Hs

    import GHC.Types.SrcLoc
    import GHC.Types.SourceFile

    import GHC.Unit.Types
    import GHC.Unit.Info

    import GHC.Utils.Outputable

    {-
    ************************************************************************
    *                                                                      *
                            User syntax
    *                                                                      *
    ************************************************************************
    -}

    data HsComponentId = HsComponentId {
        HsComponentId -> PackageName
    hsPackageName :: PackageName,
        HsComponentId -> UnitId
    hsComponentId :: UnitId
        }

    instance Outputable HsComponentId where
        ppr :: HsComponentId -> SDoc
    ppr (HsComponentId PackageName
    _pn UnitId
    cid) = UnitId -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr UnitId
    cid -- todo debug with pn

    data HsUnitId n = HsUnitId (Located n) [LHsModuleSubst n]
    type LHsUnitId n = Located (HsUnitId n)

    type HsModuleSubst n = (Located ModuleName, LHsModuleId n)
    type LHsModuleSubst n = Located (HsModuleSubst n)

    data HsModuleId n = HsModuleVar (Located ModuleName)
                      | HsModuleId (LHsUnitId n) (Located ModuleName)
    type LHsModuleId n = Located (HsModuleId n)

    -- | Top level @unit@ declaration in a Backpack file.
    data HsUnit n = HsUnit {
            forall n. HsUnit n -> Located n
    hsunitName :: Located n,
            forall n. HsUnit n -> [LHsUnitDecl n]
    hsunitBody :: [LHsUnitDecl n]
        }
    type LHsUnit n = Located (HsUnit n)

    -- | A declaration in a package, e.g. a module or signature definition,
    -- or an include.
    data HsUnitDecl n
        = DeclD   HscSource (Located ModuleName) (Located (HsModule GhcPs))
        | IncludeD   (IncludeDecl n)
    type LHsUnitDecl n = Located (HsUnitDecl n)

    -- | An include of another unit
    data IncludeDecl n = IncludeDecl {
            forall n. IncludeDecl n -> LHsUnitId n
    idUnitId :: LHsUnitId n,
            forall n. IncludeDecl n -> Maybe [LRenaming]
    idModRenaming :: Maybe [ LRenaming ],
            -- | Is this a @dependency signature@ include?  If so,
            -- we don't compile this include when we instantiate this
            -- unit (as there should not be any modules brought into
            -- scope.)
            forall n. IncludeDecl n -> Bool
    idSignatureInclude :: Bool
        }

    -- | Rename a module from one name to another.  The identity renaming
    -- means that the module should be brought into scope.
    data Renaming = Renaming { Renaming -> Located ModuleName
    renameFrom :: Located ModuleName
                             , Renaming -> Maybe (Located ModuleName)
    renameTo :: Maybe (Located ModuleName) }
    type LRenaming = Located Renaming