Add -W ghc0

Author: angerman

Cabal/src/Distribution/Simple/Configure.hs

@@ -465,7 +465,7 @@ configure_setupHooks
     let verbosity = fromFlag (configVerbosity cfg)
         distPref = fromFlag $ configDistPref cfg
         mbWorkDir = flagToMaybe $ configWorkingDir cfg
-    (lbc0, comp, platform, enabledComps) <- preConfigurePackage cfg g_pkg_descr
+    (lbc0, comp, compNative, platform, enabledComps) <- preConfigurePackage cfg g_pkg_descr
 
     -- Package-wide pre-configure hook
     lbc1 <-
@@ -547,7 +547,7 @@ configure_setupHooks
 preConfigurePackage
   :: ConfigFlags
   -> GenericPackageDescription
-  -> IO (LBC.LocalBuildConfig, Compiler, Platform, ComponentRequestedSpec)
+  -> IO (LBC.LocalBuildConfig, Compiler, Compiler, Platform, ComponentRequestedSpec)
 preConfigurePackage cfg g_pkg_descr = do
   let verbosity = fromFlag $ configVerbosity cfg
 
@@ -615,12 +615,14 @@ preConfigurePackage cfg g_pkg_descr = do
   -- programDb:  location and args of all programs we're
   --                  building with
   ( comp :: Compiler
+    , compNative :: Compiler
     , compPlatform :: Platform
     , programDb00 :: ProgramDb
     ) <-
     configCompilerEx
       (flagToMaybe (configHcFlavor cfg))
       (flagToMaybe (configHcPath cfg))
+      (flagToMaybe (configHcNativePath cfg))
       (flagToMaybe (configHcPkg cfg))
       programDbPre
       (lessVerbose verbosity)
@@ -636,7 +638,7 @@ preConfigurePackage cfg g_pkg_descr = do
     interpretSymbolicPath mbWorkDir builddir
 
   lbc <- computeLocalBuildConfig cfg comp programDb00
-  return (lbc, comp, compPlatform, enabled)
+  return (lbc, comp, compNative, compPlatform, enabled)
 
 computeLocalBuildConfig
   :: ConfigFlags
@@ -2477,34 +2479,36 @@ ccLdOptionsBuildInfo cflags ldflags ldflags_static =
 
 configCompilerAuxEx
   :: ConfigFlags
-  -> IO (Compiler, Platform, ProgramDb)
+  -> IO (Compiler, Compiler, Platform, ProgramDb)
 configCompilerAuxEx cfg = do
   programDb <- mkProgramDb cfg defaultProgramDb
   let common = configCommonFlags cfg
       verbosity = fromFlag $ setupVerbosity common
   configCompilerEx
     (flagToMaybe $ configHcFlavor cfg)
     (flagToMaybe $ configHcPath cfg)
+    (flagToMaybe $ configHcNativePath cfg)
     (flagToMaybe $ configHcPkg cfg)
     programDb
     verbosity
 
 configCompilerEx
   :: Maybe CompilerFlavor
-  -> Maybe FilePath
-  -> Maybe FilePath
+  -> Maybe FilePath -- ^ given compiler location
+  -> Maybe FilePath -- ^ given native compiler location
+  -> Maybe FilePath -- ^ given compiler package location
   -> ProgramDb
   -> Verbosity
-  -> IO (Compiler, Platform, ProgramDb)
-configCompilerEx Nothing _ _ _ verbosity = dieWithException verbosity UnknownCompilerException
-configCompilerEx (Just hcFlavor) hcPath hcPkg progdb verbosity = do
-  (comp, maybePlatform, programDb) <- case hcFlavor of
-    GHC -> GHC.configure verbosity hcPath hcPkg progdb
-    GHCJS -> GHCJS.configure verbosity hcPath hcPkg progdb
-    UHC -> UHC.configure verbosity hcPath hcPkg progdb
-    HaskellSuite{} -> HaskellSuite.configure verbosity hcPath hcPkg progdb
+  -> IO (Compiler, Compiler, Platform, ProgramDb)
+configCompilerEx Nothing _ _ _ _ verbosity = dieWithException verbosity UnknownCompilerException
+configCompilerEx (Just hcFlavor) hcPath hcNativePath hcPkg progdb verbosity = do
+  (comp, nativeComp, maybePlatform, programDb) <- case hcFlavor of
+    GHC -> GHC.configure verbosity hcPath hcNativePath hcPkg progdb
+    -- GHCJS -> GHCJS.configure verbosity hcPath hcPkg progdb
+    -- UHC -> UHC.configure verbosity hcPath hcPkg progdb
+    -- HaskellSuite{} -> HaskellSuite.configure verbosity hcPath hcPkg progdb
     _ -> dieWithException verbosity UnknownCompilerException
-  return (comp, fromMaybe buildPlatform maybePlatform, programDb)
+  return (comp, nativeComp, fromMaybe buildPlatform maybePlatform, programDb)
 
 -- -----------------------------------------------------------------------------
 -- Testing C lib and header dependencies

Cabal/src/Distribution/Simple/GHC.hs

@@ -109,7 +109,7 @@ import Distribution.Simple.PackageIndex (InstalledPackageIndex)
 import qualified Distribution.Simple.PackageIndex as PackageIndex
 import Distribution.Simple.PreProcess.Types
 import Distribution.Simple.Program
-import Distribution.Simple.Program.Builtin (runghcProgram)
+import Distribution.Simple.Program.Builtin (runghcProgram, ghcNativeProgram)
 import Distribution.Simple.Program.GHC
 import qualified Distribution.Simple.Program.HcPkg as HcPkg
 import qualified Distribution.Simple.Program.Strip as Strip
@@ -151,113 +151,139 @@ import Distribution.Simple.Setup.Build
 
 configure
   :: Verbosity
-  -> Maybe FilePath
-  -> Maybe FilePath
+  -> Maybe FilePath -- ^ given compiler location
+  -> Maybe FilePath -- ^ given native compiler location
+  -> Maybe FilePath -- ^ given compiler package location
   -> ProgramDb
-  -> IO (Compiler, Maybe Platform, ProgramDb)
-configure verbosity hcPath hcPkgPath conf0 = do
-  (ghcProg, ghcVersion, progdb1) <-
-    requireProgramVersion
-      verbosity
-      ghcProgram
-      (orLaterVersion (mkVersion [7, 0, 1]))
-      (userMaybeSpecifyPath "ghc" hcPath conf0)
-  let implInfo = ghcVersionImplInfo ghcVersion
-
-  -- Cabal currently supports ghc >= 7.0.1 && < 9.12
-  -- ... and the following odd development version
-  unless (ghcVersion < mkVersion [9, 12]) $
-    warn verbosity $
-      "Unknown/unsupported 'ghc' version detected "
-        ++ "(Cabal "
-        ++ prettyShow cabalVersion
-        ++ " supports 'ghc' version < 9.12): "
-        ++ programPath ghcProg
-        ++ " is version "
-        ++ prettyShow ghcVersion
-
-  -- This is slightly tricky, we have to configure ghc first, then we use the
-  -- location of ghc to help find ghc-pkg in the case that the user did not
-  -- specify the location of ghc-pkg directly:
-  (ghcPkgProg, ghcPkgVersion, progdb2) <-
-    requireProgramVersion
-      verbosity
-      ghcPkgProgram
-        { programFindLocation = guessGhcPkgFromGhcPath ghcProg
-        }
-      anyVersion
-      (userMaybeSpecifyPath "ghc-pkg" hcPkgPath progdb1)
-
-  when (ghcVersion /= ghcPkgVersion) $
-    dieWithException verbosity $
-      VersionMismatchGHC (programPath ghcProg) ghcVersion (programPath ghcPkgProg) ghcPkgVersion
-  -- Likewise we try to find the matching hsc2hs and haddock programs.
-  let hsc2hsProgram' =
-        hsc2hsProgram
-          { programFindLocation = guessHsc2hsFromGhcPath ghcProg
-          }
-      haddockProgram' =
-        haddockProgram
-          { programFindLocation = guessHaddockFromGhcPath ghcProg
-          }
-      hpcProgram' =
-        hpcProgram
-          { programFindLocation = guessHpcFromGhcPath ghcProg
-          }
-      runghcProgram' =
-        runghcProgram
-          { programFindLocation = guessRunghcFromGhcPath ghcProg
-          }
-      progdb3 =
-        addKnownProgram haddockProgram' $
-          addKnownProgram hsc2hsProgram' $
-            addKnownProgram hpcProgram' $
-              addKnownProgram runghcProgram' progdb2
-
-  languages <- Internal.getLanguages verbosity implInfo ghcProg
-  extensions0 <- Internal.getExtensions verbosity implInfo ghcProg
-
-  ghcInfo <- Internal.getGhcInfo verbosity implInfo ghcProg
-  let ghcInfoMap = Map.fromList ghcInfo
-      filterJS = if ghcVersion < mkVersion [9, 8] then filterExt JavaScriptFFI else id
-      extensions =
-        -- workaround https://gitlab.haskell.org/ghc/ghc/-/issues/11214
-        filterJS $
-          -- see 'filterExtTH' comment below
-          filterExtTH $
-            extensions0
-
-      -- starting with GHC 8.0, `TemplateHaskell` will be omitted from
-      -- `--supported-extensions` when it's not available.
-      -- for older GHCs we can use the "Have interpreter" property to
-      -- filter out `TemplateHaskell`
-      filterExtTH
-        | ghcVersion < mkVersion [8]
-        , Just "NO" <- Map.lookup "Have interpreter" ghcInfoMap =
-            filterExt TemplateHaskell
-        | otherwise = id
-
-      filterExt ext = filter ((/= EnableExtension ext) . fst)
-
-      compilerId :: CompilerId
-      compilerId = CompilerId GHC ghcVersion
-
-      compilerAbiTag :: AbiTag
-      compilerAbiTag = maybe NoAbiTag AbiTag (Map.lookup "Project Unit Id" ghcInfoMap >>= stripPrefix (prettyShow compilerId <> "-"))
-
-  let comp =
-        Compiler
-          { compilerId
-          , compilerAbiTag
-          , compilerCompat = []
-          , compilerLanguages = languages
-          , compilerExtensions = extensions
-          , compilerProperties = ghcInfoMap
-          }
-      compPlatform = Internal.targetPlatform ghcInfo
-      -- configure gcc and ld
-      progdb4 = Internal.configureToolchain implInfo ghcProg ghcInfoMap progdb3
-  return (comp, compPlatform, progdb4)
+  -> IO (Compiler, Compiler, Maybe Platform, ProgramDb)
+configure verbosity hcPath hcNativePath hcPkgPath conf0 = do
+    conf verbosity hcPath hcNativePath hcPkgPath conf0
+  where
+    conf :: Verbosity -> Maybe FilePath -> Maybe FilePath -> Maybe FilePath -> ProgramDb
+         -> IO (Compiler, Compiler, Maybe Platform, ProgramDb)
+    conf verbosity hcPath hcNativePath hcPkgPath conf0 = do
+      print ("conf", hcPath, hcNativePath, hcPkgPath)
+      (ghcProg, ghcVersion, progdb0) <-
+        requireProgramVersion
+          verbosity
+          ghcProgram
+          (orLaterVersion (mkVersion [7, 0, 1]))
+          (userMaybeSpecifyPath "ghc" hcPath conf0)
+
+      (ghcProg', ghcVersion', progdb1) <-
+        requireProgramVersion
+          verbosity
+          ghcNativeProgram
+          (orLaterVersion (mkVersion [7, 0, 1]))
+          (userMaybeSpecifyPath "ghc0" hcNativePath progdb0)
+
+      -- Cabal currently supports ghc >= 7.0.1 && < 9.12
+      -- ... and the following odd development version
+      unless (ghcVersion < mkVersion [9, 12]) $
+        warn verbosity $
+          "Unknown/unsupported 'ghc' version detected "
+            ++ "(Cabal "
+            ++ prettyShow cabalVersion
+            ++ " supports 'ghc' version < 9.12): "
+            ++ programPath ghcProg
+            ++ " is version "
+            ++ prettyShow ghcVersion
+
+      -- This is slightly tricky, we have to configure ghc first, then we use the
+      -- location of ghc to help find ghc-pkg in the case that the user did not
+      -- specify the location of ghc-pkg directly:
+      (ghcPkgProg, ghcPkgVersion, progdb2) <-
+        requireProgramVersion
+          verbosity
+          ghcPkgProgram
+            { programFindLocation = guessGhcPkgFromGhcPath ghcProg
+            }
+          anyVersion
+          (userMaybeSpecifyPath "ghc-pkg" hcPkgPath progdb1)
+
+      when (ghcVersion /= ghcPkgVersion) $
+        dieWithException verbosity $
+          VersionMismatchGHC (programPath ghcProg) ghcVersion (programPath ghcPkgProg) ghcPkgVersion
+      -- Likewise we try to find the matching hsc2hs and haddock programs.
+      let hsc2hsProgram' =
+            hsc2hsProgram
+              { programFindLocation = guessHsc2hsFromGhcPath ghcProg
+              }
+          haddockProgram' =
+            haddockProgram
+              { programFindLocation = guessHaddockFromGhcPath ghcProg
+              }
+          hpcProgram' =
+            hpcProgram
+              { programFindLocation = guessHpcFromGhcPath ghcProg
+              }
+          runghcProgram' =
+            runghcProgram
+              { programFindLocation = guessRunghcFromGhcPath ghcProg
+              }
+          progdb3 =
+            addKnownProgram haddockProgram' $
+              addKnownProgram hsc2hsProgram' $
+                addKnownProgram hpcProgram' $
+                  addKnownProgram runghcProgram' progdb2
+
+
+      (comp, compPlatform, progdb4) <- mkCompiler verbosity ghcProg ghcVersion progdb3
+      (comp', compPlatform', progdb5) <- mkCompiler verbosity ghcProg' ghcVersion' progdb4
+
+      return (comp, comp', compPlatform, progdb5)
+
+    mkCompiler :: Verbosity -> ConfiguredProgram -> Version -> ProgramDb -> IO (Compiler, Maybe Platform, ProgramDb)
+    mkCompiler verbosity ghcProg ghcVersion progdb = do
+      --   vvvv
+      -- > TODO <: do the same (ghcInfo, ... ) for the ghcNativeProg
+      --   ^^^^
+      let implInfo = ghcVersionImplInfo ghcVersion
+
+      languages <- Internal.getLanguages verbosity implInfo ghcProg
+      extensions0 <- Internal.getExtensions verbosity implInfo ghcProg
+      ghcInfo <- Internal.getGhcInfo verbosity implInfo ghcProg
+
+      let ghcInfoMap = Map.fromList ghcInfo
+          filterJS = if ghcVersion < mkVersion [9, 8] then filterExt JavaScriptFFI else id
+          extensions =
+            -- workaround https://gitlab.haskell.org/ghc/ghc/-/issues/11214
+            filterJS $
+              -- see 'filterExtTH' comment below
+              filterExtTH $
+                extensions0
+
+          -- starting with GHC 8.0, `TemplateHaskell` will be omitted from
+          -- `--supported-extensions` when it's not available.
+          -- for older GHCs we can use the "Have interpreter" property to
+          -- filter out `TemplateHaskell`
+          filterExtTH
+            | ghcVersion < mkVersion [8]
+            , Just "NO" <- Map.lookup "Have interpreter" ghcInfoMap =
+                filterExt TemplateHaskell
+            | otherwise = id
+
+          filterExt ext = filter ((/= EnableExtension ext) . fst)
+
+          compilerId :: CompilerId
+          compilerId = CompilerId GHC ghcVersion
+
+          compilerAbiTag :: AbiTag
+          compilerAbiTag = maybe NoAbiTag AbiTag (Map.lookup "Project Unit Id" ghcInfoMap >>= stripPrefix (prettyShow compilerId <> "-"))
+
+      let comp =
+            Compiler
+              { compilerId
+              , compilerAbiTag
+              , compilerCompat = []
+              , compilerLanguages = languages
+              , compilerExtensions = extensions
+              , compilerProperties = ghcInfoMap
+              }
+          compPlatform = Internal.targetPlatform ghcInfo
+          -- configure gcc and ld
+          progdb' = Internal.configureToolchain implInfo ghcProg ghcInfoMap progdb
+      return (comp, compPlatform, progdb')
 
 -- | Given something like /usr/local/bin/ghc-6.6.1(.exe) we try and find
 -- the corresponding tool; e.g. if the tool is ghc-pkg, we try looking

Cabal/src/Distribution/Simple/Program.hs

@@ -108,6 +108,7 @@ module Distribution.Simple.Program
 
     -- * Programs that Cabal knows about
   , ghcProgram
+  , ghcNativeProgram
   , ghcPkgProgram
   , ghcjsProgram
   , ghcjsPkgProgram