Auto merge of #28826 - arthurprs:leading_plus, r=alexcrichton

Closes #27580

src/libcore/num/mod.rs

@@ -1387,33 +1387,19 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32)
     // of multi-byte sequences
     let src = src.as_bytes();
 
-    match (src[0], &src[1..])  {
+    let (is_positive, digits) = match src[0] {
-        (b'-', digits) if digits.is_empty() => Err(PIE { kind: Empty }),
+        b'+' => (true, &src[1..]),
-        (b'-', digits) if is_signed_ty => {
+        b'-' if is_signed_ty => (false, &src[1..]),
-            // The number is negative
+        _ => (true, src)
-            let mut result = T::from_u32(0);
-            for &c in digits {
-                let x = match (c as char).to_digit(radix) {
-                    Some(x) => x,
-                    None => return Err(PIE { kind: InvalidDigit }),
-                };
-                result = match result.checked_mul(radix) {
-                    Some(result) => result,
-                    None => return Err(PIE { kind: Underflow }),
-                };
-                result = match result.checked_sub(x) {
-                    Some(result) => result,
-                    None => return Err(PIE { kind: Underflow }),
     };
+
+    if digits.is_empty() {
+        return Err(PIE { kind: Empty });
     }
-            Ok(result)
+
-        },
+    let mut result = T::from_u32(0);
-        (c, digits) => {
+    if is_positive {
-            // The number is signed
+        // The number is positive
-            let mut result = match (c as char).to_digit(radix) {
-                Some(x) => T::from_u32(x),
-                None => return Err(PIE { kind: InvalidDigit }),
-            };
         for &c in digits {
             let x = match (c as char).to_digit(radix) {
                 Some(x) => x,
@@ -1428,10 +1414,25 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32)
                 None => return Err(PIE { kind: Overflow }),
             };
         }
+    } else {
+        // The number is negative
+        for &c in digits {
+            let x = match (c as char).to_digit(radix) {
+                Some(x) => x,
+                None => return Err(PIE { kind: InvalidDigit }),
+            };
+            result = match result.checked_mul(radix) {
+                Some(result) => result,
+                None => return Err(PIE { kind: Underflow }),
+            };
+            result = match result.checked_sub(x) {
+                Some(result) => result,
+                None => return Err(PIE { kind: Underflow }),
+            };
+        }
+    }
     Ok(result)
 }
-    }
-}
 
 /// An error which can be returned when parsing an integer.
 #[derive(Debug, Clone, PartialEq)]

src/libcoretest/num/mod.rs

@@ -118,15 +118,23 @@ mod tests {
         assert_eq!("-9223372036854775809".parse::<i64>().ok(), None);
     }
 
+    #[test]
+    fn test_leading_plus() {
+        assert_eq!("+127".parse::<u8>().ok(), Some(127u8));
+        assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807i64));
+    }
+
     #[test]
     fn test_invalid() {
         assert_eq!("--129".parse::<i8>().ok(), None);
+        assert_eq!("++129".parse::<i8>().ok(), None);
         assert_eq!("Съешь".parse::<u8>().ok(), None);
     }
 
     #[test]
     fn test_empty() {
         assert_eq!("-".parse::<i8>().ok(), None);
+        assert_eq!("+".parse::<i8>().ok(), None);
         assert_eq!("".parse::<u8>().ok(), None);
     }
 }