Portage/Dependency/Normalize.hs: add 'sort_deps' pass

It is able to sort use flags of the following form:
    b? ( a? ( foo ) ) -> a? ( b? ( foo ) )

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

Portage/Dependency.hs

@@ -102,7 +102,7 @@ sortDeps = sortBy dsort . map deeper
     deeper (DependAnyOf ds)  = DependAnyOf $ sortDeps ds
     deeper x = x
     dsort :: Dependency -> Dependency -> Ordering
-    dsort (DependIfUse (DUse (_is_u1, u1)) _) (DependIfUse (DUse (_is_u2, u2)) _) = u1 `compare` u2
+    dsort (DependIfUse u1 _) (DependIfUse u2 _) = u1 `compare` u2
     dsort (DependIfUse _ _)  (DependAnyOf _)   = LT
     dsort (DependIfUse _ _)  (DependAllOf  _)   = LT
     dsort (DependIfUse _ _)  _                  = GT

Portage/Dependency/Normalize.hs

@@ -31,6 +31,7 @@ normalization_step = combine_atoms
                    . lift_context
                    . remove_duplicates
                    . remove_empty
+                   . sort_deps
 
 remove_empty :: Dependency -> Dependency
 remove_empty d =
@@ -154,6 +155,23 @@ lift_context' d =
                                        ctxes -> foldl1 L.intersect ctxes
         (Atom _pn _dr _dattr)   -> [d]
 
+-- reorders depends to make them more attractive
+-- for other normalization algorithms
+-- TODO: add all logic from 'sortDeps' here
+sort_deps :: Dependency -> Dependency
+
+-- silly bubble-sort on depends
+sort_deps d =
+    case d of
+        (DependIfUse lhs (DependIfUse rhs dep))
+            | rhs < lhs   -> DependIfUse rhs $ sort_deps $ DependIfUse lhs dep
+        (DependIfUse use dep) -> DependIfUse use $ sort_deps dep
+        (DependAnyOf deps)        -> DependAnyOf $ map sort_deps deps
+        (DependAllOf deps)        -> DependAllOf $ map sort_deps deps
+        (Atom _pn _dr _dattr)     -> d
+
+sort_deps x = x
+
 -- remove various types of redundancy
 normalize_depend :: Dependency -> Dependency
 normalize_depend d = next_step next_d

Portage/Dependency/Types.hs

@@ -61,6 +61,15 @@ data DAttr = DAttr SlotDepend [UseFlag]
 data DUse = DUse (Bool, Use)
     deriving (Eq, Show)
 
+-- sort order:
+--   a? < b?
+--   a? < !a?
+instance Ord DUse where
+    compare (DUse (lb, lname)) (DUse (rb, rname)) =
+        case compare lname rname of
+            EQ -> compare rb lb
+            v  -> v
+
 data Dependency = Atom PackageName DRange DAttr
                 | DependIfUse DUse     Dependency
                 | DependAnyOf         [Dependency]

tests/normalize_deps.hs

@@ -72,6 +72,11 @@ test_normalize_in_use_and_top = TestCase $ do
                     , "     >=dev-haskell/parsec-3.1 )"
                     ]
                   )
+                , ( d_all [ d_use "foo" $ d_use "bar" $ d_ge pnm [1,0]
+                          , d_use "bar" $ d_use "foo" $ d_ge pnm [1,0]
+                          ]
+                  , [ "bar? ( foo? ( >=dev-haskell/mtl-1.0 ) )" ]
+                  )
                 ]
     forM_ deps $ \(d, expected) ->
         let actual = P.dep2str 0 d