cli: positional arguments are invalid when parsing configuration

src/cli/args.zig

@@ -93,7 +93,22 @@ pub fn parse(
             }
         }
 
-        if (mem.startsWith(u8, arg, "--")) {
+        // If this doesn't start with "--" then it isn't a config
+        // flag. We don't support positional arguments or configuration
+        // values set with spaces so this is an error.
+        if (!mem.startsWith(u8, arg, "--")) {
+            if (comptime !canTrackDiags(T)) return Error.InvalidField;
+
+            // Add our diagnostic
+            try dst._diagnostics.append(arena_alloc, .{
+                .key = try arena_alloc.dupeZ(u8, arg),
+                .message = "invalid field",
+                .location = diags.Location.fromIter(iter),
+            });
+
+            continue;
+        }
+
         var key: []const u8 = arg[2..];
         const value: ?[]const u8 = value: {
             // If the arg has "=" then the value is after the "=".
@@ -134,7 +149,6 @@ pub fn parse(
         };
     }
 }
-}
 
 /// Returns true if this type can track diagnostics.
 fn canTrackDiags(comptime T: type) bool {
@@ -452,6 +466,27 @@ test "parse: empty value resets to default" {
     try testing.expect(!data.b);
 }
 
+test "parse: positional arguments are invalid" {
+    const testing = std.testing;
+
+    var data: struct {
+        a: u8 = 42,
+        _arena: ?ArenaAllocator = null,
+    } = .{};
+    defer if (data._arena) |arena| arena.deinit();
+
+    var iter = try std.process.ArgIteratorGeneral(.{}).init(
+        testing.allocator,
+        "--a=84 what",
+    );
+    defer iter.deinit();
+    try testing.expectError(
+        error.InvalidField,
+        parse(@TypeOf(data), testing.allocator, &data, &iter),
+    );
+    try testing.expectEqual(@as(u8, 84), data.a);
+}
+
 test "parse: diagnostic tracking" {
     const testing = std.testing;
 

src/cli/diagnostics.zig

@@ -46,6 +46,8 @@ pub const Location = union(enum) {
         line: usize,
     },
 
+    pub const Key = @typeInfo(Location).Union.tag_type.?;
+
     pub fn fromIter(iter: anytype) Location {
         const Iter = t: {
             const T = @TypeOf(iter);
@@ -121,4 +123,17 @@ pub const DiagnosticList = struct {
     pub fn items(self: *const DiagnosticList) []const Diagnostic {
         return self.list.items;
     }
+
+    /// Returns true if there are any diagnostics for the given
+    /// location type.
+    pub fn containsLocation(
+        self: *const DiagnosticList,
+        location: Location.Key,
+    ) bool {
+        for (self.list.items) |diag| {
+            if (diag.location == location) return true;
+        }
+
+        return false;
+    }
 };