Rework version range parser

- No more `try`
- It recognises wild-card version after all operators,
  but fails with more descriptive warning after non-==
  Fixes haskell#989

Cabal/Cabal.cabal

@@ -40,6 +40,8 @@ extra-source-files:
   tests/ParserTests/errors/common3.errors
   tests/ParserTests/errors/leading-comma.cabal
   tests/ParserTests/errors/leading-comma.errors
+  tests/ParserTests/errors/range-ge-wild.cabal
+  tests/ParserTests/errors/range-ge-wild.errors
   tests/ParserTests/regressions/Octree-0.5.cabal
   tests/ParserTests/regressions/Octree-0.5.format
   tests/ParserTests/regressions/common.cabal

Cabal/Distribution/Types/VersionRange.hs

@@ -411,37 +411,61 @@ instance Parsec VersionRange where
                         return (intersectVersionRanges f t)
                      <|>
                      return f)
-        factor = P.choice
-            $ parens expr
-            : parseAnyVersion
-            : parseNoVersion
-            : parseWildcardRange
-            : map parseRangeOp rangeOps
-        parseAnyVersion    = P.string "-any" >> return anyVersion
-        parseNoVersion     = P.string "-none" >> return noVersion
-
-        parseWildcardRange = P.try $ do
-          _ <- P.string "=="
-          P.spaces
-          branch <- some (P.integral <* P.char '.')
-          _ <- P.char '*'
-          return (withinVersion (mkVersion branch))
+        factor = parens expr <|> prim
+
+        prim = do
+            op <- P.munch1 (`elem` "<>=^-") P.<?> "operator"
+            case op of
+                "-" -> anyVersion <$ P.string "any" <|> noVersion <$ P.string "none"
+
+                "==" -> do
+                    P.spaces
+                    (wild, v) <- verOrWild
+                    pure $ (if wild then withinVersion else thisVersion) v
+
+                _ -> do
+                    P.spaces
+                    (wild, v) <- verOrWild
+                    when wild $ P.unexpected $
+                        "wild-card version after non-== operator: " ++ show op
+                    case op of
+                        ">="  -> pure $ orLaterVersion v
+                        "<"   -> pure $ earlierVersion v
+                        "^>=" -> pure $ majorBoundVersion v
+                        "<="  -> pure $ orEarlierVersion v
+                        ">"   -> pure $ laterVersion v
+                        _ -> fail $ "Unknown version operator " ++ show op
+
+        -- either wildcard or normal version
+        verOrWild :: CabalParsing m => m (Bool, Version)
+        verOrWild = do
+            x <- P.integral
+            verLoop (x :)
+
+        -- trailing: wildcard (.y.*) or normal version (optional tags) (.y.z-tag)
+        verLoop :: CabalParsing m => ([Int] -> [Int]) -> m (Bool, Version)
+        verLoop acc = verLoop' acc <|> (tags >> pure (False, mkVersion (acc [])))
+
+        verLoop' :: CabalParsing m => ([Int] -> [Int]) -> m (Bool, Version)
+        verLoop' acc = do
+            _ <- P.char '.'
+            ((\x -> verLoop (acc . (x :))) =<< P.integral)
+                <|> (\_ -> (True, mkVersion (acc []))) <$> P.char '*'
 
         parens p = P.between
-            (P.char '(' >> P.spaces)
+            ((P.char '(' P.<?> "opening paren") >> P.spaces)
             (P.char ')' >> P.spaces)
             (do a <- p
                 P.spaces
                 return (VersionRangeParens a))
 
-        -- TODO: make those non back-tracking
-        parseRangeOp (s,f) = P.try (P.string s *> P.spaces *> fmap f parsec)
-        rangeOps = [ ("<",  earlierVersion),
-                     ("<=", orEarlierVersion),
-                     (">",  laterVersion),
-                     (">=", orLaterVersion),
-                     ("^>=", majorBoundVersion),
-                     ("==", thisVersion) ]
+        tags :: CabalParsing m => m ()
+        tags = do
+            ts <- many $ P.char '-' *> some (P.satisfy isAlphaNum)
+            case ts of
+                []      -> pure ()
+                (_ : _) -> parsecWarning PWTVersionTag "version with tags"
+
 
 instance Text VersionRange where
   parse = expr

Cabal/tests/ParserTests.hs

@@ -81,6 +81,7 @@ errorTests = testGroup "errors"
     , errorTest "common2.cabal"
     , errorTest "common3.cabal"
     , errorTest "leading-comma.cabal"
+    , errorTest "range-ge-wild.cabal"
     ]
 
 errorTest :: FilePath -> TestTree

Cabal/tests/ParserTests/errors/range-ge-wild.cabal

@@ -0,0 +1,8 @@
+name:                range-ge-wild
+version:             0
+synopsis:            Wild range after non-== op
+build-type:          Simple
+cabal-version:       >=1.10
+
+library
+  build-depends: base >= 4.*

Cabal/tests/ParserTests/errors/range-ge-wild.errors

@@ -0,0 +1 @@
+PError (Position 8 29) "\nunexpected wild-card version after non-== operator: \">=\": \"base >= 4.*\""