Check unmatched positional arguments

src/CommandLine/Core/ValueMapper.cs

@@ -62,8 +62,19 @@ yield return
                         converted => Tuple.Create(pt.WithValue(Maybe.Just(converted)), Maybe.Nothing<Error>()),
                         Tuple.Create<SpecificationProperty, Maybe<Error>>(
                             pt, Maybe.Just<Error>(new BadFormatConversionError(NameInfo.EmptyName))));
+
+            var remainingSpecs = specProps.Skip(1);
+            var remainingValues = values.Skip(taken.Count());
+
+            if (remainingValues.Any() && remainingSpecs.Empty())
+            {
+                foreach ( var value in remainingValues )
+                {
+                    yield return Tuple.Create<SpecificationProperty, Maybe<Error>>(pt, Maybe.Just<Error>(new UnknownValueError(value)));
+                }
+            }
 
-            foreach (var value in MapValuesImpl(specProps.Skip(1), values.Skip(taken.Count()), converter))
+            foreach (var value in MapValuesImpl(remainingSpecs, remainingValues, converter))
             {
                 yield return value;
             }
@@ -92,4 +103,4 @@ private static Maybe<Error> MakeErrorInCaseOfMinConstraint(this Specification sp
                 : Maybe.Nothing<Error>();
         }
     }
-}
+}

src/CommandLine/Error.cs

@@ -24,6 +24,10 @@ public enum ErrorType
         /// </summary>
         UnknownOptionError,
         /// <summary>
+        /// Value of <see cref="CommandLine.UnknownValueError"/> type.
+        /// </summary>
+        UnknownValueError,
+        /// <summary>
         /// Value of <see cref="CommandLine.MissingRequiredOptionError"/> type.
         /// </summary>
         MissingRequiredOptionError,
@@ -344,6 +348,17 @@ internal UnknownOptionError(string token)
         }
     }
 
+    /// <summary>
+    /// Models an error generated when an unknown value is detected.
+    /// </summary>
+    public sealed class UnknownValueError : TokenError
+    {
+        internal UnknownValueError(string token)
+            : base(ErrorType.UnknownValueError, token)
+        {
+        }
+    }
+
     /// <summary>
     /// Models an error generated when a required option is required.
     /// </summary>

src/CommandLine/Parser.cs

@@ -219,7 +219,7 @@ private static ParserResult<T> DisplayHelp<T>(ParserResult<T> parserResult, Text
         private static IEnumerable<ErrorType> HandleUnknownArguments(bool ignoreUnknownArguments)
         {
             return ignoreUnknownArguments
-                ? Enumerable.Empty<ErrorType>().Concat(ErrorType.UnknownOptionError)
+                ? Enumerable.Empty<ErrorType>().Concat(ErrorType.UnknownOptionError).Concat(ErrorType.UnknownValueError)
                 : Enumerable.Empty<ErrorType>();
         }
 

src/CommandLine/Text/SentenceBuilder.cs

@@ -125,6 +125,8 @@ public override Func<string> OptionGroupWord
                                         "' has no value.");
                                 case ErrorType.UnknownOptionError:
                                     return "Option '".JoinTo(((UnknownOptionError)error).Token, "' is unknown.");
+                                case ErrorType.UnknownValueError:
+                                    return "Value '".JoinTo(((UnknownValueError)error).Token, "' is unknown.");
                                 case ErrorType.MissingRequiredOptionError:
                                     var errMisssing = ((MissingRequiredOptionError)error);
                                     return errMisssing.NameInfo.Equals(NameInfo.EmptyName)

tests/CommandLine.Tests/Unit/Issue847Tests.cs

@@ -0,0 +1,56 @@
+using FluentAssertions;
+using System.Linq;
+using Xunit;
+
+// Issue #847
+// no parsing error if additional positional argument is present
+
+namespace CommandLine.Tests.Unit
+{
+    public class Issue847Tests
+    {
+        [Fact]
+        public void IgnoreUnknownArguments_should_work_for_values()
+        {
+            var arguments = new[] { "foo", "bar", "too_much" };
+            var result = new Parser(with => { with.IgnoreUnknownArguments = true; })
+                .ParseArguments<Options>(arguments);
+
+            Assert.Empty(result.Errors);
+            Assert.Equal(ParserResultType.Parsed, result.Tag);
+
+            result.WithParsed(options =>
+            {
+                options.Foo.Should().Be("foo");
+                options.Bar.Should().Be("bar");
+            });
+        }
+
+        [Fact]
+        public void Additional_positional_arguments_should_raise_errors()
+        {
+            var arguments = new[] { "foo", "bar", "too_much" };
+            var result = new Parser(with => { with.IgnoreUnknownArguments = false; })
+                .ParseArguments<Options>(arguments);
+
+            Assert.NotEmpty(result.Errors);
+            Assert.Equal(ParserResultType.NotParsed, result.Tag);
+
+            result.WithNotParsed(errors =>
+            {
+                Assert.NotEmpty(errors);
+                Assert.IsType<UnknownValueError>(errors.Single());
+            });
+        }
+
+        private class Options
+        {
+            [Value(0, Required = true)]
+            public string Foo { get; set; }
+
+
+            [Value(1, Required = false)]
+            public string Bar { get; set; }
+        }
+    }
+}