diff --git a/src/build/arg/mod.rs b/src/build/arg/mod.rs
index 773745c3cc0..b1fe9f5ecef 100644
--- a/src/build/arg/mod.rs
+++ b/src/build/arg/mod.rs
@@ -2039,6 +2039,8 @@ impl<'help> Arg<'help> {
     /// [`Arg::multiple_occurrences(true)`] would allow `-f <file> <file> <file> -f <file> <file> <file>` where
     /// as *not* setting it would only allow one occurrence of this argument.
     ///
+    /// **NOTE:** implicitly sets [`Arg::takes_value(true)`] and [`Arg::multiple_values(true)`].
+    ///
     /// # Examples
     ///
     /// ```rust
@@ -2450,9 +2452,7 @@ impl<'help> Arg<'help> {
     /// **Pro Tip:** It may help to use [`Arg::next_line_help(true)`] if there are long, or
     /// multiple value names in order to not throw off the help text alignment of all options.
     ///
-    /// **NOTE:** implicitly sets [`Arg::takes_value(true)`]
-    ///
-    /// **NOTE:** Does *not* require or imply [`Arg::multiple_values(true)`].
+    /// **NOTE:** implicitly sets [`Arg::takes_value(true)`] and [`Arg::multiple_values(true)`].
     ///
     /// # Examples
     ///
@@ -4583,6 +4583,8 @@ impl<'help> Arg<'help> {
     ///
     /// Currently this is only supported by the zsh completions generator.
     ///
+    /// **NOTE:** implicitly sets [`Arg::takes_value(true)`].
+    ///
     /// For example, to take a username as argument:
     ///
     /// ```
@@ -4607,13 +4609,15 @@ impl<'help> Arg<'help> {
     ///     );
     /// ```
     pub fn value_hint(mut self, value_hint: ValueHint) -> Self {
-        self.settings.set(ArgSettings::TakesValue);
         self.value_hint = value_hint;
-        self
+        self.takes_value(true)
     }
 
-    // FIXME: (@CreepySkeleton)
     pub(crate) fn _build(&mut self) {
+        if self.is_positional() {
+            self.settings.set(ArgSettings::TakesValue);
+        }
+
         if (self.is_set(ArgSettings::UseValueDelimiter)
             || self.is_set(ArgSettings::RequireDelimiter))
             && self.val_delim.is_none()
@@ -4621,15 +4625,14 @@ impl<'help> Arg<'help> {
             self.val_delim = Some(',');
         }
 
-        if !(self.index.is_some() || self.is_positional())
-            && self.is_set(ArgSettings::TakesValue)
-            && self.val_names.len() > 1
-        {
-            self.num_vals = Some(self.val_names.len());
-        }
+        let val_names_len = self.val_names.len();
 
-        if self.is_positional() {
-            self.settings.set(ArgSettings::TakesValue);
+        if val_names_len > 1 {
+            self.settings.set(ArgSettings::MultipleValues);
+
+            if self.num_vals.is_none() {
+                self.num_vals = Some(val_names_len);
+            }
         }
     }
 
@@ -4772,11 +4775,7 @@ impl<'help> From<&'help Yaml> for Arg<'help> {
                 "possible_values" => yaml_vec_or_str!(a, v, possible_value),
                 "case_insensitive" => yaml_to_bool!(a, v, case_insensitive),
                 "required_unless_present_any" => yaml_vec!(a, v, required_unless_present_any),
-                "required_unless_present_all" => {
-                    a = yaml_vec!(a, v, required_unless_present_all);
-                    a.settings.set(ArgSettings::RequiredUnlessAll);
-                    a
-                }
+                "required_unless_present_all" => yaml_vec!(a, v, required_unless_present_all),
                 "visible_alias" => yaml_to_str!(a, v, visible_alias),
                 "visible_aliases" => yaml_vec_or_str!(a, v, visible_alias),
                 "visible_short_alias" => yaml_to_char!(a, v, visible_short_alias),
@@ -5010,8 +5009,7 @@ mod test {
 
     #[test]
     fn flag_display() {
-        let mut f = Arg::new("flg");
-        f.settings.set(ArgSettings::MultipleOccurrences);
+        let mut f = Arg::new("flg").setting(ArgSettings::MultipleOccurrences);
         f.long = Some("flag");
 
         assert_eq!(&*format!("{}", f), "--flag");
@@ -5174,18 +5172,17 @@ mod test {
 
     #[test]
     fn positional_display_val_names() {
-        let mut p2 = Arg::new("pos").index(1);
-        let vm = vec!["file1", "file2"];
-        p2.val_names = vm;
+        let p2 = Arg::new("pos").index(1).value_names(&["file1", "file2"]);
 
         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
     }
 
     #[test]
     fn positional_display_val_names_req() {
-        let mut p2 = Arg::new("pos").index(1).setting(ArgSettings::Required);
-        let vm = vec!["file1", "file2"];
-        p2.val_names = vm;
+        let p2 = Arg::new("pos")
+            .index(1)
+            .setting(ArgSettings::Required)
+            .value_names(&["file1", "file2"]);
 
         assert_eq!(&*format!("{}", p2), "<file1> <file2>");
     }
diff --git a/src/build/usage_parser.rs b/src/build/usage_parser.rs
index 31746a50392..3383ae371be 100644
--- a/src/build/usage_parser.rs
+++ b/src/build/usage_parser.rs
@@ -64,16 +64,13 @@ impl<'help> UsageParser<'help> {
                 break;
             }
         }
-        arg.num_vals = if arg.val_names.len() > 1 {
-            Some(arg.val_names.len())
-        } else {
-            None
-        };
+
         if arg.is_positional() && arg.is_set(ArgSettings::MultipleOccurrences) {
             // We had a positional and need to set mult vals too
             arg.settings.set(ArgSettings::MultipleValues);
             arg.settings.unset(ArgSettings::MultipleOccurrences);
         }
+
         debug!("UsageParser::parse: vals...{:?}", arg.val_names);
         arg
     }
@@ -264,7 +261,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] --flag 'some help info'");
         assert_eq!(a.name, "flag");
@@ -273,7 +269,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flag 'some help info'");
         assert_eq!(a.name, "flag");
@@ -282,7 +277,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f --flag 'some help info'");
         assert_eq!(a.name, "flag");
@@ -291,7 +285,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f... 'some help info'");
         assert_eq!(a.name, "flag");
@@ -300,7 +293,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flag] -f --flag... 'some help info'");
         assert_eq!(a.name, "flag");
@@ -309,7 +301,6 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f --flag... 'some help info'");
         assert_eq!(a.name, "flag");
@@ -318,33 +309,28 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flags");
         assert_eq!(a.name, "flags");
         assert_eq!(a.long.unwrap(), "flags");
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("--flags...");
         assert_eq!(a.name, "flags");
         assert_eq!(a.long.unwrap(), "flags");
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flags] -f");
         assert_eq!(a.name, "flags");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("[flags] -f...");
         assert_eq!(a.name, "flags");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f 'some help info'");
         assert_eq!(a.name, "f");
@@ -353,20 +339,17 @@ mod test {
         assert_eq!(a.about.unwrap(), "some help info");
         assert!(!a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f");
         assert_eq!(a.name, "f");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
 
         let a = Arg::from("-f...");
         assert_eq!(a.name, "f");
         assert_eq!(a.short.unwrap(), 'f');
         assert!(a.is_set(ArgSettings::MultipleOccurrences));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -382,7 +365,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -397,7 +379,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -412,7 +393,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -427,7 +407,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -442,7 +421,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -456,7 +434,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -471,7 +448,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -486,7 +462,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -500,7 +475,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -515,7 +489,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -530,7 +503,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -545,7 +517,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -560,7 +531,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -575,7 +545,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -590,7 +559,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -604,7 +572,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -619,7 +586,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -634,7 +600,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -648,7 +613,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -664,7 +628,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -680,7 +643,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -696,7 +658,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -712,7 +673,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -728,7 +688,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -744,7 +703,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -758,7 +716,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -774,7 +731,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -790,7 +746,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -804,7 +759,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -820,7 +774,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -836,7 +789,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -852,7 +804,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -868,7 +819,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -884,7 +834,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -898,7 +847,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -914,7 +862,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -928,7 +875,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -944,7 +890,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -960,7 +905,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -976,7 +920,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -992,7 +935,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1008,7 +950,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1022,7 +963,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1038,7 +978,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1052,7 +991,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1068,7 +1006,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1084,7 +1021,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
     }
 
     #[test]
@@ -1100,7 +1036,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
     }
 
     #[test]
@@ -1116,7 +1051,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
     }
 
     #[test]
@@ -1132,7 +1066,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
     }
 
     #[test]
@@ -1147,7 +1080,6 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
-        assert_eq!(a.num_vals.unwrap(), 2);
     }
 
     #[test]
@@ -1160,7 +1092,6 @@ mod test {
         );
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1173,7 +1104,6 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1184,7 +1114,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1195,7 +1124,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1206,7 +1134,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1220,7 +1147,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1234,7 +1160,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1245,7 +1170,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1257,7 +1181,6 @@ mod test {
         );
         assert!(a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1267,7 +1190,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(!a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
     }
 
     #[test]
@@ -1278,7 +1200,6 @@ mod test {
         assert!(a.is_set(ArgSettings::MultipleValues));
         assert!(a.is_set(ArgSettings::Required));
         assert!(a.val_names.is_empty());
-        assert!(a.num_vals.is_none());
         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
@@ -1295,7 +1216,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
@@ -1312,7 +1232,6 @@ mod test {
         assert!(a.is_set(ArgSettings::TakesValue));
         assert!(!a.is_set(ArgSettings::Required));
         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
-        assert_eq!(a.num_vals.unwrap(), 2);
         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
     }
 
diff --git a/tests/multiple_values.rs b/tests/multiple_values.rs
index 81705e89f8f..abd7bc34a68 100644
--- a/tests/multiple_values.rs
+++ b/tests/multiple_values.rs
@@ -1250,3 +1250,72 @@ fn issue_2229() {
     assert!(m.is_err()); // This panics, because `m.is_err() == false`.
     assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
 }
+
+#[test]
+fn value_names_building_num_vals() {
+    let m = App::new("test")
+        .arg(
+            Arg::new("pos")
+                .long("pos")
+                .value_names(&["who", "what", "why"]),
+        )
+        .try_get_matches_from(vec!["myprog", "--pos", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
+    let m = m.unwrap();
+
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_names_building_num_vals_from_usage() {
+    let m = App::new("test")
+        .arg(Arg::from("--pos <who> <what> <why>"))
+        .try_get_matches_from(vec!["myprog", "--pos", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
+    let m = m.unwrap();
+
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn value_names_building_num_vals_for_positional() {
+    let m = App::new("test")
+        .arg(Arg::new("pos").value_names(&["who", "what", "why"]))
+        .try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
+
+    assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
+    let m = m.unwrap();
+
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3"]
+    );
+}
+
+#[test]
+fn number_of_values_preferred_over_value_names() {
+    let m = App::new("test")
+        .arg(
+            Arg::new("pos")
+                .long("pos")
+                .number_of_values(4)
+                .value_names(&["who", "what", "why"]),
+        )
+        .try_get_matches_from(vec!["myprog", "--pos", "val1", "val2", "val3", "val4"]);
+
+    assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
+    let m = m.unwrap();
+
+    assert_eq!(
+        m.values_of("pos").unwrap().collect::<Vec<_>>(),
+        ["val1", "val2", "val3", "val4"]
+    );
+}