Make OS, Arch, CompilerInfo optionals in IndexConversion

The rational here is that we might now know the OS/Arch/Compiler when converting the Package Information. In the case of cross compilation, the build and host compiler are not the same hence we can't pre-fill these. However they may share some commonality which we can pre-fill. In the case where host = build, we can fill out all, in all other cases
we may only be able to fill out partials of OS/Arch/Compiler. In the extreme case where all are different (compile from aarch64-linux with 9.8 to x86_64-windows at 9.12).

Author: angerman

cabal-install-solver/src/Distribution/Solver/Modular/IndexConversion.hs

@@ -53,13 +53,13 @@ import Distribution.Solver.Modular.Version
 -- resolving these situations. However, the right thing to do is to
 -- fix the problem there, so for now, shadowing is only activated if
 -- explicitly requested.
-convPIs :: OS -> Arch -> CompilerInfo -> Map PN [LabeledPackageConstraint]
+convPIs :: Maybe OS -> Maybe Arch -> Maybe CompilerInfo -> Map PN [LabeledPackageConstraint]
         -> ShadowPkgs -> StrongFlags -> SolveExecutables
         -> SI.InstalledPackageIndex -> CI.PackageIndex (SourcePackage loc)
         -> Index
-convPIs os arch comp constraints sip strfl solveExes iidx sidx =
+convPIs mos march mcomp constraints sip strfl solveExes iidx sidx =
   mkIndex $
-  convIPI' sip iidx ++ convSPI' os arch comp constraints strfl solveExes sidx
+  convIPI' sip iidx ++ convSPI' mos march mcomp constraints strfl solveExes sidx
 
 -- | Convert a Cabal installed package index to the simpler,
 -- more uniform index format of the solver.
@@ -153,29 +153,29 @@ convIPId dr comp idx ipid =
 
 -- | Convert a cabal-install source package index to the simpler,
 -- more uniform index format of the solver.
-convSPI' :: OS -> Arch -> CompilerInfo -> Map PN [LabeledPackageConstraint]
+convSPI' :: Maybe OS -> Maybe Arch -> Maybe CompilerInfo -> Map PN [LabeledPackageConstraint]
          -> StrongFlags -> SolveExecutables
          -> CI.PackageIndex (SourcePackage loc) -> [(PN, I, PInfo)]
-convSPI' os arch cinfo constraints strfl solveExes =
-    L.map (convSP os arch cinfo constraints strfl solveExes) . CI.allPackages
+convSPI' mos march mcinfo constraints strfl solveExes =
+    L.map (convSP mos march mcinfo constraints strfl solveExes) . CI.allPackages
 
 -- | Convert a single source package into the solver-specific format.
-convSP :: OS -> Arch -> CompilerInfo -> Map PN [LabeledPackageConstraint]
+convSP :: Maybe OS -> Maybe Arch -> Maybe CompilerInfo -> Map PN [LabeledPackageConstraint]
        -> StrongFlags -> SolveExecutables -> SourcePackage loc -> (PN, I, PInfo)
-convSP os arch cinfo constraints strfl solveExes (SourcePackage (PackageIdentifier pn pv) gpd _ _pl) =
+convSP mos march mcinfo constraints strfl solveExes (SourcePackage (PackageIdentifier pn pv) gpd _ _pl) =
   let i = I pv InRepo
       pkgConstraints = fromMaybe [] $ M.lookup pn constraints
-  in  (pn, i, convGPD os arch cinfo pkgConstraints strfl solveExes pn gpd)
+  in  (pn, i, convGPD mos march mcinfo pkgConstraints strfl solveExes pn gpd)
 
 -- We do not use 'flattenPackageDescription' or 'finalizePD'
 -- from 'Distribution.PackageDescription.Configuration' here, because we
 -- want to keep the condition tree, but simplify much of the test.
 
 -- | Convert a generic package description to a solver-specific 'PInfo'.
-convGPD :: OS -> Arch -> CompilerInfo -> [LabeledPackageConstraint]
+convGPD :: Maybe OS -> Maybe Arch -> Maybe CompilerInfo -> [LabeledPackageConstraint]
         -> StrongFlags -> SolveExecutables -> PN -> GenericPackageDescription
         -> PInfo
-convGPD os arch cinfo constraints strfl solveExes pn
+convGPD mos march mcinfo constraints strfl solveExes pn
         (GenericPackageDescription pkg scannedVersion flags mlib sub_libs flibs exes tests benchs) =
   let
     fds  = flagInfo strfl flags
@@ -184,7 +184,7 @@ convGPD os arch cinfo constraints strfl solveExes pn
     conv :: Monoid a => Component -> (a -> BuildInfo) -> DependencyReason PN ->
             CondTree ConfVar [Dependency] a -> FlaggedDeps PN
     conv comp getInfo dr =
-        convCondTree M.empty dr pkg os arch cinfo pn fds comp getInfo solveExes .
+        convCondTree M.empty dr pkg mos march mcinfo pn fds comp getInfo solveExes .
         addBuildableCondition getInfo
 
     initDR = DependencyReason pn M.empty S.empty
@@ -233,7 +233,7 @@ convGPD os arch cinfo constraints strfl solveExes pn
               , compIsBuildable = IsBuildable $ testCondition (buildable . libBuildInfo) lib /= Just False
               }
 
-        testCondition = testConditionForComponent os arch cinfo constraints
+        testCondition = testConditionForComponent mos march mcinfo constraints
 
         isPrivate LibraryVisibilityPrivate = True
         isPrivate LibraryVisibilityPublic  = False
@@ -246,14 +246,14 @@ convGPD os arch cinfo constraints strfl solveExes pn
 -- before dependency solving. Additionally, this function only considers flags
 -- that are set by unqualified flag constraints, and it doesn't check the
 -- intra-package dependencies of a component.
-testConditionForComponent :: OS
-                          -> Arch
-                          -> CompilerInfo
+testConditionForComponent :: Maybe OS
+                          -> Maybe Arch
+                          -> Maybe CompilerInfo
                           -> [LabeledPackageConstraint]
                           -> (a -> Bool)
                           -> CondTree ConfVar [Dependency] a
                           -> Maybe Bool
-testConditionForComponent os arch cinfo constraints p tree =
+testConditionForComponent mos march mcinfo constraints p tree =
     case go $ extractCondition p tree of
       Lit True  -> Just True
       Lit False -> Just False
@@ -269,16 +269,17 @@ testConditionForComponent os arch cinfo constraints p tree =
     -- function was copied from convBranch and
     -- Distribution.Types.Condition.simplifyCondition.
     go :: Condition ConfVar -> Condition ConfVar
-    go (Var (OS os')) = Lit (os == os')
-    go (Var (Arch arch')) = Lit (arch == arch')
-    go (Var (Impl cf cvr))
-        | matchImpl (compilerInfoId cinfo) ||
-              -- fixme: Nothing should be treated as unknown, rather than empty
-              --        list. This code should eventually be changed to either
-              --        support partial resolution of compiler flags or to
-              --        complain about incompletely configured compilers.
-          any matchImpl (fromMaybe [] $ compilerInfoCompat cinfo) = Lit True
-        | otherwise = Lit False
+    go (Var (OS os')) | Just os <- mos = Lit (os == os')
+    go (Var (Arch arch')) | Just arch <- march = Lit (arch == arch')
+    go (Var (Impl cf cvr)) | Just cinfo <- mcinfo =
+        if matchImpl (compilerInfoId cinfo) ||
+                -- fixme: Nothing should be treated as unknown, rather than empty
+                --        list. This code should eventually be changed to either
+                --        support partial resolution of compiler flags or to
+                --        complain about incompletely configured compilers.
+            any matchImpl (fromMaybe [] $ compilerInfoCompat cinfo)
+        then Lit True
+        else Lit False
       where
         matchImpl (CompilerId cf' cv) = cf == cf' && checkVR cvr cv
     go (Var (PackageFlag f))
@@ -325,12 +326,13 @@ flagInfo (StrongFlags strfl) =
 -- | Convert condition trees to flagged dependencies.  Mutually
 -- recursive with 'convBranch'.  See 'convBranch' for an explanation
 -- of all arguments preceding the input 'CondTree'.
-convCondTree :: Map FlagName Bool -> DependencyReason PN -> PackageDescription -> OS -> Arch -> CompilerInfo -> PN -> FlagInfo ->
+convCondTree :: Map FlagName Bool -> DependencyReason PN -> PackageDescription ->
+                Maybe OS -> Maybe Arch -> Maybe CompilerInfo -> PN -> FlagInfo ->
                 Component ->
                 (a -> BuildInfo) ->
                 SolveExecutables ->
                 CondTree ConfVar [Dependency] a -> FlaggedDeps PN
-convCondTree flags dr pkg os arch cinfo pn fds comp getInfo solveExes@(SolveExecutables solveExes') (CondNode info ds branches) =
+convCondTree flags dr pkg mos march mcinfo pn fds comp getInfo solveExes@(SolveExecutables solveExes') (CondNode info ds branches) =
              -- Merge all library and build-tool dependencies at every level in
              -- the tree of flagged dependencies. Otherwise 'extractCommon'
              -- could create duplicate dependencies, and the number of
@@ -344,7 +346,7 @@ convCondTree flags dr pkg os arch cinfo pn fds comp getInfo solveExes@(SolveExec
               ++ L.map (\e -> D.Simple (LDep dr (Ext  e)) comp) (allExtensions bi) -- unconditional extension dependencies
               ++ L.map (\l -> D.Simple (LDep dr (Lang l)) comp) (allLanguages  bi) -- unconditional language dependencies
               ++ L.map (\(PkgconfigDependency pkn vr) -> D.Simple (LDep dr (Pkg pkn vr)) comp) (pkgconfigDepends bi) -- unconditional pkg-config dependencies
-              ++ concatMap (convBranch flags dr pkg os arch cinfo pn fds comp getInfo solveExes) branches
+              ++ concatMap (convBranch flags dr pkg mos march mcinfo pn fds comp getInfo solveExes) branches
               -- build-tools dependencies
               -- NB: Only include these dependencies if SolveExecutables
               -- is True.  It might be false in the legacy solver
@@ -453,20 +455,20 @@ mergeSimpleDeps deps = L.map (uncurry toFlaggedDep) (M.toList merged) ++ unmerge
 convBranch :: Map FlagName Bool
            -> DependencyReason PN
            -> PackageDescription
-           -> OS
-           -> Arch
-           -> CompilerInfo
+           -> Maybe OS
+           -> Maybe Arch
+           -> Maybe CompilerInfo
            -> PN
            -> FlagInfo
            -> Component
            -> (a -> BuildInfo)
            -> SolveExecutables
            -> CondBranch ConfVar [Dependency] a
            -> FlaggedDeps PN
-convBranch flags dr pkg os arch cinfo pn fds comp getInfo solveExes (CondBranch c' t' mf') =
+convBranch flags dr pkg mos march mcinfo pn fds comp getInfo solveExes (CondBranch c' t' mf') =
     go c'
-       (\flags' dr' ->           convCondTree flags' dr' pkg os arch cinfo pn fds comp getInfo solveExes  t')
-       (\flags' dr' -> maybe [] (convCondTree flags' dr' pkg os arch cinfo pn fds comp getInfo solveExes) mf')
+       (\flags' dr' ->           convCondTree flags' dr' pkg mos march mcinfo pn fds comp getInfo solveExes  t')
+       (\flags' dr' -> maybe [] (convCondTree flags' dr' pkg mos march mcinfo pn fds comp getInfo solveExes) mf')
        flags dr
   where
     go :: Condition ConfVar
@@ -496,19 +498,19 @@ convBranch flags dr pkg os arch cinfo pn fds comp getInfo solveExes (CondBranch
                 ++ [ Flagged (FN pn fn) (fds M.! fn) (t (addFlag True)  (addFlagValue FlagTrue))
                                                      (f (addFlag False) (addFlagValue FlagFalse)) ]
     go (Var (OS os')) t f
-      | os == os'      = t
-      | otherwise      = f
+      | Just os <- mos = if os == os' then t else f
     go (Var (Arch arch')) t f
-      | arch == arch'  = t
-      | otherwise      = f
+      | Just arch <- march = if arch == arch' then t else f
     go (Var (Impl cf cvr)) t f
-      | matchImpl (compilerInfoId cinfo) ||
+      | Just cinfo <- mcinfo =
+        if matchImpl (compilerInfoId cinfo) ||
             -- fixme: Nothing should be treated as unknown, rather than empty
             --        list. This code should eventually be changed to either
             --        support partial resolution of compiler flags or to
             --        complain about incompletely configured compilers.
-        any matchImpl (fromMaybe [] $ compilerInfoCompat cinfo) = t
-      | otherwise      = f
+            any matchImpl (fromMaybe [] $ compilerInfoCompat cinfo)
+        then t
+        else f
       where
         matchImpl (CompilerId cf' cv) = cf == cf' && checkVR cvr cv