    module Distribution.Types.BuildInfo.Lens (
        BuildInfo,
        HasBuildInfo (..),
        HasBuildInfos (..),
        ) where

    import Distribution.Compat.Lens
    import Distribution.Compat.Prelude
    import Prelude ()

    import Distribution.Compiler                  (PerCompilerFlavor)
    import Distribution.ModuleName                (ModuleName)
    import Distribution.Types.BuildInfo           (BuildInfo)
    import Distribution.Types.Dependency          (Dependency)
    import Distribution.Types.ExeDependency       (ExeDependency)
    import Distribution.Types.LegacyExeDependency (LegacyExeDependency)
    import Distribution.Types.Mixin               (Mixin)
    import Distribution.Types.PkgconfigDependency (PkgconfigDependency)
    import Distribution.Utils.Path
    import Language.Haskell.Extension             (Extension, Language)

    import qualified Distribution.Types.BuildInfo as T

    -- | Classy lenses for 'BuildInfo'.
    class HasBuildInfo a where
       buildInfo :: Lens' a BuildInfo

       buildable :: Lens' a Bool
       buildable = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a Bool
    buildable
       {-# INLINE buildable #-}

       buildTools :: Lens' a [LegacyExeDependency]
       buildTools = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [LegacyExeDependency]
    buildTools
       {-# INLINE buildTools #-}

       buildToolDepends :: Lens' a [ExeDependency]
       buildToolDepends = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [ExeDependency]
    buildToolDepends
       {-# INLINE buildToolDepends #-}

       cppOptions :: Lens' a [String]
       cppOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cppOptions
       {-# INLINE cppOptions #-}

       asmOptions :: Lens' a [String]
       asmOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    asmOptions
       {-# INLINE asmOptions #-}

       cmmOptions :: Lens' a [String]
       cmmOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cmmOptions
       {-# INLINE cmmOptions #-}

       ccOptions :: Lens' a [String]
       ccOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    ccOptions
       {-# INLINE ccOptions #-}

       cxxOptions :: Lens' a [String]
       cxxOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cxxOptions
       {-# INLINE cxxOptions #-}

       ldOptions :: Lens' a [String]
       ldOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    ldOptions
       {-# INLINE ldOptions #-}

       hsc2hsOptions :: Lens' a [String]
       hsc2hsOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    hsc2hsOptions
       {-# INLINE hsc2hsOptions #-}

       pkgconfigDepends :: Lens' a [PkgconfigDependency]
       pkgconfigDepends = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [PkgconfigDependency]
    pkgconfigDepends
       {-# INLINE pkgconfigDepends #-}

       frameworks :: Lens' a [String]
       frameworks = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    frameworks
       {-# INLINE frameworks #-}

       extraFrameworkDirs :: Lens' a [String]
       extraFrameworkDirs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraFrameworkDirs
       {-# INLINE extraFrameworkDirs #-}

       asmSources :: Lens' a [FilePath]
       asmSources = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    asmSources
       {-# INLINE asmSources #-}

       cmmSources :: Lens' a [FilePath]
       cmmSources = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cmmSources
       {-# INLINE cmmSources #-}

       cSources :: Lens' a [FilePath]
       cSources = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cSources
       {-# INLINE cSources #-}

       cxxSources :: Lens' a [FilePath]
       cxxSources = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    cxxSources
       {-# INLINE cxxSources #-}

       jsSources :: Lens' a [FilePath]
       jsSources = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    jsSources
       {-# INLINE jsSources #-}

       hsSourceDirs :: Lens' a [SymbolicPath PackageDir SourceDir]
       hsSourceDirs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a.
    HasBuildInfo a =>
    Lens' a [SymbolicPath PackageDir SourceDir]
    hsSourceDirs
       {-# INLINE hsSourceDirs #-}

       otherModules :: Lens' a [ModuleName]
       otherModules = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [ModuleName]
    otherModules
       {-# INLINE otherModules #-}

       virtualModules :: Lens' a [ModuleName]
       virtualModules = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [ModuleName]
    virtualModules
       {-# INLINE virtualModules #-}

       autogenModules :: Lens' a [ModuleName]
       autogenModules = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [ModuleName]
    autogenModules
       {-# INLINE autogenModules #-}

       defaultLanguage :: Lens' a (Maybe Language)
       defaultLanguage = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a (Maybe Language)
    defaultLanguage
       {-# INLINE defaultLanguage #-}

       otherLanguages :: Lens' a [Language]
       otherLanguages = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Language]
    otherLanguages
       {-# INLINE otherLanguages #-}

       defaultExtensions :: Lens' a [Extension]
       defaultExtensions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Extension]
    defaultExtensions
       {-# INLINE defaultExtensions #-}

       otherExtensions :: Lens' a [Extension]
       otherExtensions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Extension]
    otherExtensions
       {-# INLINE otherExtensions #-}

       oldExtensions :: Lens' a [Extension]
       oldExtensions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Extension]
    oldExtensions
       {-# INLINE oldExtensions #-}

       extraLibs :: Lens' a [String]
       extraLibs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraLibs
       {-# INLINE extraLibs #-}

       extraGHCiLibs :: Lens' a [String]
       extraGHCiLibs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraGHCiLibs
       {-# INLINE extraGHCiLibs #-}

       extraBundledLibs :: Lens' a [String]
       extraBundledLibs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraBundledLibs
       {-# INLINE extraBundledLibs #-}

       extraLibFlavours :: Lens' a [String]
       extraLibFlavours = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraLibFlavours
       {-# INLINE extraLibFlavours #-}

       extraDynLibFlavours :: Lens' a [String]
       extraDynLibFlavours = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraDynLibFlavours
       {-# INLINE extraDynLibFlavours #-}

       extraLibDirs :: Lens' a [String]
       extraLibDirs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    extraLibDirs
       {-# INLINE extraLibDirs #-}

       includeDirs :: Lens' a [FilePath]
       includeDirs = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    includeDirs
       {-# INLINE includeDirs #-}

       includes :: Lens' a [FilePath]
       includes = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    includes
       {-# INLINE includes #-}

       autogenIncludes :: Lens' a [FilePath]
       autogenIncludes = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    autogenIncludes
       {-# INLINE autogenIncludes #-}

       installIncludes :: Lens' a [FilePath]
       installIncludes = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [String]
    installIncludes
       {-# INLINE installIncludes #-}

       options :: Lens' a (PerCompilerFlavor [String])
       options = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a (PerCompilerFlavor [String])
    options
       {-# INLINE options #-}

       profOptions :: Lens' a (PerCompilerFlavor [String])
       profOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a (PerCompilerFlavor [String])
    profOptions
       {-# INLINE profOptions #-}

       sharedOptions :: Lens' a (PerCompilerFlavor [String])
       sharedOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a (PerCompilerFlavor [String])
    sharedOptions
       {-# INLINE sharedOptions #-}

       staticOptions :: Lens' a (PerCompilerFlavor [String])
       staticOptions = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a (PerCompilerFlavor [String])
    staticOptions
       {-# INLINE staticOptions #-}

       customFieldsBI :: Lens' a [(String,String)]
       customFieldsBI = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [(String, String)]
    customFieldsBI
       {-# INLINE customFieldsBI #-}

       targetBuildDepends :: Lens' a [Dependency]
       targetBuildDepends = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Dependency]
    targetBuildDepends
       {-# INLINE targetBuildDepends #-}

       mixins :: Lens' a [Mixin]
       mixins = forall a. HasBuildInfo a => Lens' a BuildInfo
    buildInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
    . forall a. HasBuildInfo a => Lens' a [Mixin]
    mixins
       {-# INLINE mixins #-}

    instance HasBuildInfo BuildInfo where
        buildInfo :: Lens' BuildInfo BuildInfo
    buildInfo = forall a. a -> a
    id
        {-# INLINE buildInfo #-}

        buildable :: Lens' BuildInfo Bool
    buildable Bool -> f Bool
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Bool
    x -> BuildInfo
    s { buildable :: Bool
    T.buildable = Bool
    x }) (Bool -> f Bool
    f (BuildInfo -> Bool
    T.buildable BuildInfo
    s))
        {-# INLINE buildable #-}

        buildTools :: Lens' BuildInfo [LegacyExeDependency]
    buildTools [LegacyExeDependency] -> f [LegacyExeDependency]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[LegacyExeDependency]
    x -> BuildInfo
    s { buildTools :: [LegacyExeDependency]
    T.buildTools = [LegacyExeDependency]
    x }) ([LegacyExeDependency] -> f [LegacyExeDependency]
    f (BuildInfo -> [LegacyExeDependency]
    T.buildTools BuildInfo
    s))
        {-# INLINE buildTools #-}

        buildToolDepends :: Lens' BuildInfo [ExeDependency]
    buildToolDepends [ExeDependency] -> f [ExeDependency]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ExeDependency]
    x -> BuildInfo
    s { buildToolDepends :: [ExeDependency]
    T.buildToolDepends = [ExeDependency]
    x }) ([ExeDependency] -> f [ExeDependency]
    f (BuildInfo -> [ExeDependency]
    T.buildToolDepends BuildInfo
    s))
        {-# INLINE buildToolDepends #-}

        cppOptions :: Lens' BuildInfo [String]
    cppOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cppOptions :: [String]
    T.cppOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cppOptions BuildInfo
    s))
        {-# INLINE cppOptions #-}

        asmOptions :: Lens' BuildInfo [String]
    asmOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { asmOptions :: [String]
    T.asmOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.asmOptions BuildInfo
    s))
        {-# INLINE asmOptions #-}

        cmmOptions :: Lens' BuildInfo [String]
    cmmOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cmmOptions :: [String]
    T.cmmOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cmmOptions BuildInfo
    s))
        {-# INLINE cmmOptions #-}

        ccOptions :: Lens' BuildInfo [String]
    ccOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { ccOptions :: [String]
    T.ccOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.ccOptions BuildInfo
    s))
        {-# INLINE ccOptions #-}

        cxxOptions :: Lens' BuildInfo [String]
    cxxOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cxxOptions :: [String]
    T.cxxOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cxxOptions BuildInfo
    s))
        {-# INLINE cxxOptions #-}

        ldOptions :: Lens' BuildInfo [String]
    ldOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { ldOptions :: [String]
    T.ldOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.ldOptions BuildInfo
    s))
        {-# INLINE ldOptions #-}

        hsc2hsOptions :: Lens' BuildInfo [String]
    hsc2hsOptions [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { hsc2hsOptions :: [String]
    T.hsc2hsOptions = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.hsc2hsOptions BuildInfo
    s))
        {-# INLINE hsc2hsOptions #-}

        pkgconfigDepends :: Lens' BuildInfo [PkgconfigDependency]
    pkgconfigDepends [PkgconfigDependency] -> f [PkgconfigDependency]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[PkgconfigDependency]
    x -> BuildInfo
    s { pkgconfigDepends :: [PkgconfigDependency]
    T.pkgconfigDepends = [PkgconfigDependency]
    x }) ([PkgconfigDependency] -> f [PkgconfigDependency]
    f (BuildInfo -> [PkgconfigDependency]
    T.pkgconfigDepends BuildInfo
    s))
        {-# INLINE pkgconfigDepends #-}

        frameworks :: Lens' BuildInfo [String]
    frameworks [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { frameworks :: [String]
    T.frameworks = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.frameworks BuildInfo
    s))
        {-# INLINE frameworks #-}

        extraFrameworkDirs :: Lens' BuildInfo [String]
    extraFrameworkDirs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraFrameworkDirs :: [String]
    T.extraFrameworkDirs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraFrameworkDirs BuildInfo
    s))
        {-# INLINE extraFrameworkDirs #-}

        asmSources :: Lens' BuildInfo [String]
    asmSources [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { asmSources :: [String]
    T.asmSources = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.asmSources BuildInfo
    s))
        {-# INLINE asmSources #-}

        cmmSources :: Lens' BuildInfo [String]
    cmmSources [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cmmSources :: [String]
    T.cmmSources = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cmmSources BuildInfo
    s))
        {-# INLINE cmmSources #-}

        cSources :: Lens' BuildInfo [String]
    cSources [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cSources :: [String]
    T.cSources = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cSources BuildInfo
    s))
        {-# INLINE cSources #-}

        cxxSources :: Lens' BuildInfo [String]
    cxxSources [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { cSources :: [String]
    T.cSources = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.cxxSources BuildInfo
    s))
        {-# INLINE cxxSources #-}

        jsSources :: Lens' BuildInfo [String]
    jsSources [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { jsSources :: [String]
    T.jsSources = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.jsSources BuildInfo
    s))
        {-# INLINE jsSources #-}

        hsSourceDirs :: Lens' BuildInfo [SymbolicPath PackageDir SourceDir]
    hsSourceDirs [SymbolicPath PackageDir SourceDir]
    -> f [SymbolicPath PackageDir SourceDir]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[SymbolicPath PackageDir SourceDir]
    x -> BuildInfo
    s { hsSourceDirs :: [SymbolicPath PackageDir SourceDir]
    T.hsSourceDirs = [SymbolicPath PackageDir SourceDir]
    x }) ([SymbolicPath PackageDir SourceDir]
    -> f [SymbolicPath PackageDir SourceDir]
    f (BuildInfo -> [SymbolicPath PackageDir SourceDir]
    T.hsSourceDirs BuildInfo
    s))
        {-# INLINE hsSourceDirs #-}

        otherModules :: Lens' BuildInfo [ModuleName]
    otherModules [ModuleName] -> f [ModuleName]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ModuleName]
    x -> BuildInfo
    s { otherModules :: [ModuleName]
    T.otherModules = [ModuleName]
    x }) ([ModuleName] -> f [ModuleName]
    f (BuildInfo -> [ModuleName]
    T.otherModules BuildInfo
    s))
        {-# INLINE otherModules #-}

        virtualModules :: Lens' BuildInfo [ModuleName]
    virtualModules [ModuleName] -> f [ModuleName]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ModuleName]
    x -> BuildInfo
    s { virtualModules :: [ModuleName]
    T.virtualModules = [ModuleName]
    x }) ([ModuleName] -> f [ModuleName]
    f (BuildInfo -> [ModuleName]
    T.virtualModules BuildInfo
    s))
        {-# INLINE virtualModules #-}

        autogenModules :: Lens' BuildInfo [ModuleName]
    autogenModules [ModuleName] -> f [ModuleName]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ModuleName]
    x -> BuildInfo
    s { autogenModules :: [ModuleName]
    T.autogenModules = [ModuleName]
    x }) ([ModuleName] -> f [ModuleName]
    f (BuildInfo -> [ModuleName]
    T.autogenModules BuildInfo
    s))
        {-# INLINE autogenModules #-}

        defaultLanguage :: Lens' BuildInfo (Maybe Language)
    defaultLanguage Maybe Language -> f (Maybe Language)
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Maybe Language
    x -> BuildInfo
    s { defaultLanguage :: Maybe Language
    T.defaultLanguage = Maybe Language
    x }) (Maybe Language -> f (Maybe Language)
    f (BuildInfo -> Maybe Language
    T.defaultLanguage BuildInfo
    s))
        {-# INLINE defaultLanguage #-}

        otherLanguages :: Lens' BuildInfo [Language]
    otherLanguages [Language] -> f [Language]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Language]
    x -> BuildInfo
    s { otherLanguages :: [Language]
    T.otherLanguages = [Language]
    x }) ([Language] -> f [Language]
    f (BuildInfo -> [Language]
    T.otherLanguages BuildInfo
    s))
        {-# INLINE otherLanguages #-}

        defaultExtensions :: Lens' BuildInfo [Extension]
    defaultExtensions [Extension] -> f [Extension]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Extension]
    x -> BuildInfo
    s { defaultExtensions :: [Extension]
    T.defaultExtensions = [Extension]
    x }) ([Extension] -> f [Extension]
    f (BuildInfo -> [Extension]
    T.defaultExtensions BuildInfo
    s))
        {-# INLINE defaultExtensions #-}

        otherExtensions :: Lens' BuildInfo [Extension]
    otherExtensions [Extension] -> f [Extension]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Extension]
    x -> BuildInfo
    s { otherExtensions :: [Extension]
    T.otherExtensions = [Extension]
    x }) ([Extension] -> f [Extension]
    f (BuildInfo -> [Extension]
    T.otherExtensions BuildInfo
    s))
        {-# INLINE otherExtensions #-}

        oldExtensions :: Lens' BuildInfo [Extension]
    oldExtensions [Extension] -> f [Extension]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Extension]
    x -> BuildInfo
    s { oldExtensions :: [Extension]
    T.oldExtensions = [Extension]
    x }) ([Extension] -> f [Extension]
    f (BuildInfo -> [Extension]
    T.oldExtensions BuildInfo
    s))
        {-# INLINE oldExtensions #-}

        extraLibs :: Lens' BuildInfo [String]
    extraLibs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraLibs :: [String]
    T.extraLibs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraLibs BuildInfo
    s))
        {-# INLINE extraLibs #-}

        extraGHCiLibs :: Lens' BuildInfo [String]
    extraGHCiLibs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraGHCiLibs :: [String]
    T.extraGHCiLibs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraGHCiLibs BuildInfo
    s))
        {-# INLINE extraGHCiLibs #-}

        extraBundledLibs :: Lens' BuildInfo [String]
    extraBundledLibs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraBundledLibs :: [String]
    T.extraBundledLibs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraBundledLibs BuildInfo
    s))
        {-# INLINE extraBundledLibs #-}

        extraLibFlavours :: Lens' BuildInfo [String]
    extraLibFlavours [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraLibFlavours :: [String]
    T.extraLibFlavours = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraLibFlavours BuildInfo
    s))
        {-# INLINE extraLibFlavours #-}

        extraDynLibFlavours :: Lens' BuildInfo [String]
    extraDynLibFlavours [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraDynLibFlavours :: [String]
    T.extraDynLibFlavours = [String]
    x}) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraDynLibFlavours BuildInfo
    s))
        {-# INLINE extraDynLibFlavours #-}

        extraLibDirs :: Lens' BuildInfo [String]
    extraLibDirs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { extraLibDirs :: [String]
    T.extraLibDirs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.extraLibDirs BuildInfo
    s))
        {-# INLINE extraLibDirs #-}

        includeDirs :: Lens' BuildInfo [String]
    includeDirs [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { includeDirs :: [String]
    T.includeDirs = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.includeDirs BuildInfo
    s))
        {-# INLINE includeDirs #-}

        includes :: Lens' BuildInfo [String]
    includes [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { includes :: [String]
    T.includes = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.includes BuildInfo
    s))
        {-# INLINE includes #-}

        autogenIncludes :: Lens' BuildInfo [String]
    autogenIncludes [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { autogenIncludes :: [String]
    T.autogenIncludes = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.autogenIncludes BuildInfo
    s))
        {-# INLINE autogenIncludes #-}

        installIncludes :: Lens' BuildInfo [String]
    installIncludes [String] -> f [String]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> BuildInfo
    s { installIncludes :: [String]
    T.installIncludes = [String]
    x }) ([String] -> f [String]
    f (BuildInfo -> [String]
    T.installIncludes BuildInfo
    s))
        {-# INLINE installIncludes #-}

        options :: Lens' BuildInfo (PerCompilerFlavor [String])
    options PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\PerCompilerFlavor [String]
    x -> BuildInfo
    s { options :: PerCompilerFlavor [String]
    T.options = PerCompilerFlavor [String]
    x }) (PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f (BuildInfo -> PerCompilerFlavor [String]
    T.options BuildInfo
    s))
        {-# INLINE options #-}

        profOptions :: Lens' BuildInfo (PerCompilerFlavor [String])
    profOptions PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\PerCompilerFlavor [String]
    x -> BuildInfo
    s { profOptions :: PerCompilerFlavor [String]
    T.profOptions = PerCompilerFlavor [String]
    x }) (PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f (BuildInfo -> PerCompilerFlavor [String]
    T.profOptions BuildInfo
    s))
        {-# INLINE profOptions #-}

        sharedOptions :: Lens' BuildInfo (PerCompilerFlavor [String])
    sharedOptions PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\PerCompilerFlavor [String]
    x -> BuildInfo
    s { sharedOptions :: PerCompilerFlavor [String]
    T.sharedOptions = PerCompilerFlavor [String]
    x }) (PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f (BuildInfo -> PerCompilerFlavor [String]
    T.sharedOptions BuildInfo
    s))
        {-# INLINE sharedOptions #-}

        staticOptions :: Lens' BuildInfo (PerCompilerFlavor [String])
    staticOptions PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\PerCompilerFlavor [String]
    x -> BuildInfo
    s { staticOptions :: PerCompilerFlavor [String]
    T.staticOptions = PerCompilerFlavor [String]
    x }) (PerCompilerFlavor [String] -> f (PerCompilerFlavor [String])
    f (BuildInfo -> PerCompilerFlavor [String]
    T.staticOptions BuildInfo
    s))
        {-# INLINE staticOptions #-}

        customFieldsBI :: Lens' BuildInfo [(String, String)]
    customFieldsBI [(String, String)] -> f [(String, String)]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[(String, String)]
    x -> BuildInfo
    s { customFieldsBI :: [(String, String)]
    T.customFieldsBI = [(String, String)]
    x }) ([(String, String)] -> f [(String, String)]
    f (BuildInfo -> [(String, String)]
    T.customFieldsBI BuildInfo
    s))
        {-# INLINE customFieldsBI #-}

        targetBuildDepends :: Lens' BuildInfo [Dependency]
    targetBuildDepends [Dependency] -> f [Dependency]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Dependency]
    x -> BuildInfo
    s { targetBuildDepends :: [Dependency]
    T.targetBuildDepends = [Dependency]
    x }) ([Dependency] -> f [Dependency]
    f (BuildInfo -> [Dependency]
    T.targetBuildDepends BuildInfo
    s))
        {-# INLINE targetBuildDepends #-}

        mixins :: Lens' BuildInfo [Mixin]
    mixins [Mixin] -> f [Mixin]
    f BuildInfo
    s = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[Mixin]
    x -> BuildInfo
    s { mixins :: [Mixin]
    T.mixins = [Mixin]
    x }) ([Mixin] -> f [Mixin]
    f (BuildInfo -> [Mixin]
    T.mixins BuildInfo
    s))
        {-# INLINE mixins #-}

    class HasBuildInfos a where
      traverseBuildInfos :: Traversal' a BuildInfo