Fri Jun 17 18:54:53 2022 UTC ()

tests/lint: make 'expect+-' comments stricter

Previously, the expectations from these comments were already satisfied
if the expectation occurred somewhere in the actual message from lint.
This meant that the prefix 'error:' or 'warning:' could be omitted from
the 'expect' comment.  These omissions were hard to see in a manual
review.  Now any omissions must be visually marked with '...'.

The test msg_342 now reports its messages properly as being in the file
msg_342.c, rather than msg_341.c.  This had been a copy-and-paste
mistake.


(rillig)

--- src/tests/usr.bin/xlint/Attic/check-expect.lua 2022/06/17 16:10:10	1.20
+++ src/tests/usr.bin/xlint/Attic/check-expect.lua 2022/06/17 18:54:53	1.21

 @@ -1,49 +1,61 @@
 #!  /usr/bin/lua
--- $NetBSD: check-expect.lua,v 1.20 2022/06/17 16:10:10 rillig Exp $
+-- $NetBSD: check-expect.lua,v 1.21 2022/06/17 18:54:53 rillig Exp $
 --[[
 usage: lua ./check-expect.lua *.c
 Check that the /* expect+-n: ... */ comments in the .c source files match the
 actual messages found in the corresponding .exp files.
 To regenerate the .exp files, see lint1/accept.sh.
 ]]
 local function test(func)
   func()
 end
 local function assert_equals(got, expected)
   if got ~= expected then
     assert(false, string.format("got %q, expected %q", got, expected))
   end
 end
 local had_errors = false
 ---@param fmt string
 function print_error(fmt, ...)
   print(fmt:format(...))
   had_errors = true
 end
 local function load_lines(fname)
   local lines = {}
   local f = io.open(fname, "r")
   if f == nil then return nil end
   for line in f:lines() do
     table.insert(lines, line)
   end
   f:close()
   return lines
 end
 -- Load the 'expect:' comments from a C source file.
 --
 -- example return values:
 --   {
 --     ["file.c(18)"] = {"invalid argument 'a'", "invalid argument 'b'"},
 --     ["file.c(23)"] = {"not a constant expression [123]"},
 --   },
 --   { "file.c(18)", "file.c(23)" }
 local function load_c(fname)
   local lines = load_lines(fname)
   if lines == nil then return nil, nil end
 @@ -104,52 +116,98 @@ local function load_exp(exp_fname)
     for location, message in line:gmatch("(%S+%(%d+%)): (.+)$") do
       table.insert(messages, {
         exp_lineno = exp_lineno,
         location = location,
         message = message
       })
     end
   end
   return messages
 end
 ---@param comment string
 ---@param pattern string
 ---@return boolean
 local function matches(comment, pattern)
   if comment == "" then return false end
   local any_prefix = pattern:sub(1, 3) == "..."
   if any_prefix then pattern = pattern:sub(4) end
   local any_suffix = pattern:sub(-3) == "..."
   if any_suffix then pattern = pattern:sub(1, -4) end
   if any_prefix and any_suffix then
     return comment:find(pattern, 1, true) ~= nil
   elseif any_prefix then
     return pattern ~= "" and comment:sub(-#pattern) == pattern
   elseif any_suffix then
     return comment:sub(1, #pattern) == pattern
   else
     return comment == pattern
   end
 end
 test(function()
   assert_equals(matches("a", "a"), true)
   assert_equals(matches("a", "b"), false)
   assert_equals(matches("a", "aaa"), false)
   assert_equals(matches("abc", "a..."), true)
   assert_equals(matches("abc", "c..."), false)
   assert_equals(matches("abc", "...c"), true)
   assert_equals(matches("abc", "...a"), false)
   assert_equals(matches("abc123xyz", "...a..."), true)
   assert_equals(matches("abc123xyz", "...b..."), true)
   assert_equals(matches("abc123xyz", "...c..."), true)
   assert_equals(matches("abc123xyz", "...1..."), true)
   assert_equals(matches("abc123xyz", "...2..."), true)
   assert_equals(matches("abc123xyz", "...3..."), true)
   assert_equals(matches("abc123xyz", "...x..."), true)
   assert_equals(matches("abc123xyz", "...y..."), true)
   assert_equals(matches("abc123xyz", "...z..."), true)
   assert_equals(matches("pattern", "...pattern..."), true)
 end)
 local function check_test(c_fname)
   local exp_fname = c_fname:gsub("%.c$", ".exp")
   local c_comment_locations, c_comments_by_location = load_c(c_fname)
   if c_comment_locations == nil then return end
   local exp_messages = load_exp(exp_fname)
   if exp_messages == nil then return end
   for _, exp_message in ipairs(exp_messages) do
     local c_comments = c_comments_by_location[exp_message.location] or {}
-    local expected_comment =
+    local expected_message =
       exp_message.message:gsub("/%*", "**"):gsub("%*/", "**")
     local found = false
     for i, c_comment in ipairs(c_comments) do
-      if c_comment ~= "" and expected_comment:find(c_comment, 1, true) then
+      if c_comment ~= "" and matches(expected_message, c_comment) then
         c_comments[i] = ""
         found = true
         break
       end
     end
     if not found then
       print_error("error: %s: missing /* expect+1: %s */",
-        exp_message.location, expected_comment)
+        exp_message.location, expected_message)
     end
   end
   for _, c_comment_location in ipairs(c_comment_locations) do
     for _, c_comment in ipairs(c_comments_by_location[c_comment_location]) do
       if c_comment ~= "" then
         print_error(
           "error: %s: declared message \"%s\" is not in the actual output",
           c_comment_location, c_comment)
       end
     end
   end
 end

--- src/tests/usr.bin/xlint/lint1/c11_generic_expression.c 2022/01/15 14:22:03	1.11
+++ src/tests/usr.bin/xlint/lint1/c11_generic_expression.c 2022/06/17 18:54:53	1.12

 @@ -1,90 +1,90 @@
-/*	$NetBSD: c11_generic_expression.c,v 1.11 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: c11_generic_expression.c,v 1.12 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "c11_generic_expression.c"
 /*
  * C99 added support for type-generic macros, but these were limited to the
  * header <tgmath.h>.  C11 made this feature generally available.
+ *
  * The generic selection is typically used with macros, but since lint1 works
  * on the preprocessed source, the test cases look a bit strange.
+ *
  * C99 6.5.1.1 "Generic selection"
  */
 /* lint1-extra-flags: -Ac11 */
 /*
  * The type of 'var' is not compatible with any of the types from the
  * generic-association.  This is a compile-time error.
  */
 const char *
 classify_type_without_default(double var)
+{
-	/* expect-2: argument 'var' unused */
+	/* expect-2: warning: argument 'var' unused in function 'classify_type_without_default' [231] */
 	return _Generic(var,
 	    long double: "long double",
 	    long long: "long long",
 	    unsigned: "unsigned"
 	);
-	/* expect-1: expects to return value [214] */
+	/* expect-1: warning: function 'classify_type_without_default' expects to return value [214] */
+}
 /*
  * In this case, the 'default' expression is selected.
  */
 const char *
 classify_type_with_default(double var)
+{
-	/* expect-2: argument 'var' unused */
+	/* expect-2: warning: argument 'var' unused in function 'classify_type_with_default' [231] */
 	return _Generic(var,
 	    long double: "long double",
 	    long long: "long long",
 	    unsigned: "unsigned",
 	    default: "unknown"
 	);
+}
 /*
  * The type of a _Generic expression is the one from the selected association.
  */
 const char *
 classify_char(char c)
+{
-	/* expect-2: argument 'c' unused */
+	/* expect-2: warning: argument 'c' unused in function 'classify_char' [231] */
 	return _Generic(c,
 	    char: "yes",
 	    default: 0.0
 	);
+}
 /*
  * Before cgram.y 1.238 from 2021-06-27, lint accepted a comma-expression,
  * which looked as if _Generic would accept multiple arguments before the
  * selection.
  */
 /* ARGSUSED */
 const int *
 comma_expression(char first, double second)
+{
 	/* expect+1: error: syntax error 'second' [249] */
 	return _Generic(first, second,
 	    char: "first",
 	    double: 2.0
 	);
-	/* expect+1: without returning value [217] */
+	/* expect+1: warning: function comma_expression falls off bottom without returning value [217] */
+}
 /*
  * Ensure that assignment-expressions are accepted by the grammar, as
  * opposed to comma-expressions.
  */
 /* ARGSUSED */
 int
 assignment_expression(int first, int second)
+{
 	return _Generic(first = second,
 	    int: second = first
 	);

--- src/tests/usr.bin/xlint/lint1/msg_249.c 2022/06/16 21:24:41	1.11
+++ src/tests/usr.bin/xlint/lint1/msg_249.c 2022/06/17 18:54:53	1.12

 @@ -1,31 +1,31 @@
-/*	$NetBSD: msg_249.c,v 1.11 2022/06/16 21:24:41 rillig Exp $	*/
+/*	$NetBSD: msg_249.c,v 1.12 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_249.c"
 // Test for message: syntax error '%s' [249]
 /*
  * Cover the grammar rule 'top_level_declaration: error T_SEMI'.
  */
-/* expect+1: syntax error '"' [249] */
+/* expect+1: error: syntax error '"' [249] */
 "syntax error in top_level_declaration";
 /* XXX: This is necessary to recover the yacc parser. */
 int recover_from_semi;
 /*
  * Cover the grammar rule 'top_level_declaration: error T_RBRACE'.
  */
-/* expect+1: syntax error '"' [249] */
+/* expect+1: error: syntax error '"' [249] */
 "syntax error in top_level_declaration"}
 /* XXX: This is necessary to recover the yacc parser. */
 int recover_from_rbrace;
 /*
  * Before func.c 1.110 from 2021-06-19, lint ran into this:
  * assertion "cstmt->c_kind == kind" failed in end_control_statement
  */
 void
 function(void)
+{
 	/* expect+2: warning: statement not reached [193] */

--- src/tests/usr.bin/xlint/lint1/d_c99_init.c 2022/01/15 14:22:03	1.40
+++ src/tests/usr.bin/xlint/lint1/d_c99_init.c 2022/06/17 18:54:53	1.41

 @@ -1,14 +1,14 @@
-/*	$NetBSD: d_c99_init.c,v 1.40 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: d_c99_init.c,v 1.41 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "d_c99_init.c"
 /*
  * Test C99 initializers.
+ *
  * See C99 6.7.8 "Initialization".
 */
 void use(const void *);
 typedef struct any {
 	const void *value;
 @@ -212,46 +212,46 @@ struct geometry {
 	struct pentagon pentagons[6];
 	struct triangle triangles[10];
 	struct point points[3][5][2];
 };
 /*
  * Initialization of a complex struct containing nested arrays and nested
  * structs.
  */
 struct geometry geometry = {
 	.pentagons[0].points[4].x = 1,
 	.points[0][0][0] = { 0, 0 },
 	.points[2][4][1] = {301, 302 },
-	/* expect+1: array subscript cannot be > 2: 3 */
+	/* expect+1: error: array subscript cannot be > 2: 3 [168] */
 	.points[3][0][0] = {3001, 3002 },
-	/* expect+1: array subscript cannot be > 4: 5 */
+	/* expect+1: error: array subscript cannot be > 4: 5 [168] */
 	.points[0][5][0] = {501, 502 },
-	/* expect+1: array subscript cannot be > 1: 2 */
+	/* expect+1: error: array subscript cannot be > 1: 2 [168] */
 	.points[0][0][2] = {21, 22 },
 };
 struct ends_with_unnamed_bit_field {
 	int member;
 	int:0;
 } ends_with_unnamed_bit_field = {
 ,
-	/* expect+1: too many struct/union initializers */
+	/* expect+1: error: too many struct/union initializers [172] */
 ,
 };
 char prefixed_message[] = {
 	'E', ':', ' ',
-	/* expect+1: illegal combination of integer (char) and pointer */
+	/* expect+1: warning: illegal combination of integer (char) and pointer (pointer to char) [183] */
 	"message\n",
 };
 char message_with_suffix[] = {
 	"message",
 	/* The excess character is not detected by lint but by compilers. */
 	'\n',
 };
 struct ten {
 	int i0;
 	int i1;
 	int i2;

--- src/tests/usr.bin/xlint/lint1/d_init_array_using_string.c 2022/01/15 14:22:03	1.10
+++ src/tests/usr.bin/xlint/lint1/d_init_array_using_string.c 2022/06/17 18:54:53	1.11

 @@ -1,14 +1,14 @@
-/*	$NetBSD: d_init_array_using_string.c,v 1.10 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: d_init_array_using_string.c,v 1.11 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "d_init_array_using_string.c"
 /*
  * Test initialization of arrays and pointers by string literals.
  */
 void sink(const void *);
 void
 test_assignment_initialization(void)
+{
 	const char *cs_match = "";
 	const int *ws_match = L"";
 @@ -62,24 +62,24 @@ test_array_initialization_in_struct(void
 	struct cs_ws type_mismatch = {
 		/* expect+1: warning: illegal combination of integer (char) and pointer (pointer to int) [183] */
 		L"",
 		/* expect+1: warning: illegal combination of integer (char) and pointer (pointer to char) [183] */
 		"",
 	};
 	struct cs_ws no_terminating_null = {
 		"0123456789",
 		L"0123456789",
 	};
 	struct cs_ws too_many_characters = {
-		/* expect+1: warning: string literal too long (11) for target array (10) */
+		/* expect+1: warning: string literal too long (11) for target array (10) [187] */
 		"0123456789X",
-		/* expect+1: warning: string literal too long (11) for target array (10) */
+		/* expect+1: warning: string literal too long (11) for target array (10) [187] */
 		L"0123456789X",
 	};
 	struct cs_ws extra_braces = {
 		{ "" },
 		{ L"" },
 	};
+}

--- src/tests/usr.bin/xlint/lint1/gcc_attribute.c 2021/07/15 21:00:05	1.10
+++ src/tests/usr.bin/xlint/lint1/gcc_attribute.c 2022/06/17 18:54:53	1.11

 @@ -1,14 +1,14 @@
-/*	$NetBSD: gcc_attribute.c,v 1.10 2021/07/15 21:00:05 rillig Exp $	*/
+/*	$NetBSD: gcc_attribute.c,v 1.11 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_attribute.c"
 /*
  * Tests for the various attributes for functions, types, statements that are
  * provided by GCC.
+ *
  * https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html
  */
 void __attribute__((noinline))
 do_not_inline(void)
+{
+}
 @@ -19,27 +19,27 @@ function_nonnull(void *, const void *, i
 /*
  * The documentation suggests that the argument list of nonnull be nonempty,
  * but GCC 9.3.0 accepts an empty list as well, treating all parameters as
  * nonnull.
  */
 void __attribute__((nonnull()))
 function_nonnull_list(void *, const void *, int);
 /* Arguments 1 and 2 must be nonnull. */
 void __attribute__((nonnull(1, 2)))
 function_nonnull_list(void *, const void *, int);
-/* expect+1: syntax error 'unknown_attribute' */
+/* expect+1: error: syntax error 'unknown_attribute' [249] */
 void __attribute__((unknown_attribute))
 function_with_unknown_attribute(void);
 /*
  * There is an attribute called 'pcs', but that attribute must not prevent an
  * ordinary variable from being named the same.  Starting with scan.l 1.77
  * from 2017-01-07, that variable name generated a syntax error.  Fixed in
  * lex.c 1.33 from 2021-05-03.
+ *
  * Seen in yds.c, function yds_allocate_slots.
  */
 int
 local_variable_pcs(void)
 @@ -115,15 +115,15 @@ __attribute__((deprecated("d5")))
     void
     __attribute__((deprecated("d7")))
+    )
     __attribute__((deprecated("d8")))
+;
 /*
  * The attribute 'const' provides stronger guarantees than 'pure', and
  * 'volatile' is not defined.  To keep the grammar simple, any T_QUAL is
  * allowed at this point, but only syntactically.
  */
 int const_function(int) __attribute__((const));
 /* cover 'gcc_attribute_spec: T_QUAL' */
-/* expect+1: syntax error 'volatile' [249] */
+/* expect+1: error: syntax error 'volatile' [249] */
 int volatile_function(int) __attribute__((volatile));

--- src/tests/usr.bin/xlint/lint1/msg_155.c 2022/04/01 22:28:21	1.10
+++ src/tests/usr.bin/xlint/lint1/msg_155.c 2022/06/17 18:54:53	1.11

 @@ -1,79 +1,79 @@
-/*	$NetBSD: msg_155.c,v 1.10 2022/04/01 22:28:21 rillig Exp $	*/
+/*	$NetBSD: msg_155.c,v 1.11 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_155.c"
 // Test for message: passing '%s' to incompatible '%s', arg #%d [155]
 void c99_6_7_6_example_a(int);
 void c99_6_7_6_example_b(int *);
 void c99_6_7_6_example_c(int *[3]);
 void c99_6_7_6_example_d(int (*)[3]);
 void c99_6_7_6_example_e(int (*)[*]);
 /* Wrong type before decl.c 1.256 from 2022-04-01. */
 void c99_6_7_6_example_f(int *());
 void c99_6_7_6_example_g(int (*)(void));
 void c99_6_7_6_example_h(int (*const[])(unsigned int, ...));
 struct incompatible {
 	int member;
 };
 void
 provoke_error_messages(struct incompatible arg)
+{
-	/* expect+1: 'int' */
+	/* expect+1: ... 'int', ... */
 	c99_6_7_6_example_a(arg);
-	/* expect+1: 'pointer to int' */
+	/* expect+1: ... 'pointer to int', ... */
 	c99_6_7_6_example_b(arg);
 	/* C99 says 'array[3] of pointer to int', which is close enough. */
-	/* expect+1: 'pointer to pointer to int' */
+	/* expect+1: ... 'pointer to pointer to int', ... */
 	c99_6_7_6_example_c(arg);
-	/* expect+1: 'pointer to array[3] of int' */
+	/* expect+1: ... 'pointer to array[3] of int', ... */
 	c99_6_7_6_example_d(arg);
-	/* expect+1: 'pointer to array[unknown_size] of int' */
+	/* expect+1: ... 'pointer to array[unknown_size] of int', ... */
 	c99_6_7_6_example_e(arg);
 	/* Wrong type before decl.c 1.256 from 2022-04-01. */
-	/* expect+1: 'pointer to function() returning pointer to int' */
+	/* expect+1: ... 'pointer to function() returning pointer to int', ... */
 	c99_6_7_6_example_f(arg);
-	/* expect+1: 'pointer to function(void) returning int' */
+	/* expect+1: ... 'pointer to function(void) returning int', ... */
 	c99_6_7_6_example_g(arg);
-	/* expect+1: 'pointer to const pointer to function(unsigned int, ...) returning int' */
+	/* expect+1: ... 'pointer to const pointer to function(unsigned int, ...) returning int', ... */
 	c99_6_7_6_example_h(arg);
+}
 extern void sink(struct incompatible);
 /*
  * The function type_name has a special case for an enum type that has been
  * implicitly converted to an int.  Such a type is still output as the enum
  * type.
+ *
  * XXX: The expressions 'day + 0' and '0 + day' should result in the same
  *  type.
  */
 void
 type_name_of_enum(void)
+{
 	enum Day {
 		MONDAY
 	} day = MONDAY;
-	/* expect+1: passing 'enum Day' */
+	/* expect+1: ... passing 'enum Day' ... */
 	sink(day);
-	/* expect+1: passing 'enum Day' */
+	/* expect+1: ... passing 'enum Day' ... */
 	sink(day + 0);
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	sink(0 + day);
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	sink(0);
+}

--- src/tests/usr.bin/xlint/lint1/decl.c 2022/06/11 11:52:13	1.16
+++ src/tests/usr.bin/xlint/lint1/decl.c 2022/06/17 18:54:53	1.17

 @@ -1,14 +1,14 @@
-/*	$NetBSD: decl.c,v 1.16 2022/06/11 11:52:13 rillig Exp $	*/
+/*	$NetBSD: decl.c,v 1.17 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "decl.c"
 /*
  * Tests for declarations, especially the distinction between the
  * declaration-specifiers and the declarators.
  */
 /*
  * Even though 'const' comes after 'char' and is therefore quite close to the
  * first identifier, it applies to both identifiers.
  */
 void
 specifier_qualifier(void)
 @@ -29,64 +29,64 @@ void
 qualifier_specifier(void)
+{
 	const char a = 1, b = 2;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	a = 3;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	b = 5;
+}
 void
 declarator_with_prefix_qualifier(void)
+{
-	/* expect+1: syntax error 'const' [249] */
+	/* expect+1: error: syntax error 'const' [249] */
 	char a = 1, const b = 2;
 	a = 1;
 	/* expect+1: error: 'b' undefined [99] */
 	b = 2;
+}
 void
 declarator_with_postfix_qualifier(void)
+{
-	/* expect+1: syntax error 'const' [249] */
+	/* expect+1: error: syntax error 'const' [249] */
 	char a = 1, b const = 2;
 	a = 1;
 	b = 2;
+}
 void sink(double *);
 void
 declarators(void)
+{
 	char *pc = 0, c = 0, **ppc = 0;
-	/* expect+1: warning: converting 'pointer to char' to incompatible 'pointer to double' */
+	/* expect+1: warning: converting 'pointer to char' to incompatible 'pointer to double' for argument 1 [153] */
 	sink(pc);
-	/* expect+1: warning: illegal combination of pointer (pointer to double) and integer (char) */
+	/* expect+1: warning: illegal combination of pointer (pointer to double) and integer (char), arg #1 [154] */
 	sink(c);
-	/* expect+1: converting 'pointer to pointer to char' to incompatible 'pointer to double' */
+	/* expect+1: warning: converting 'pointer to pointer to char' to incompatible 'pointer to double' for argument 1 [153] */
 	sink(ppc);
+}
 _Bool
 enum_error_handling(void)
+{
 	enum {
-		/* expect+1: syntax error '"' [249] */
+		/* expect+1: error: syntax error '"' [249] */
 		"error 1"
 		:		/* still the same error */
 		,		/* back on track */
 		A,
+		B
 	} x = A;
 	return x == B;
+}
 /*
  * An __attribute__ at the beginning of a declaration may become ambiguous
  * since a GCC fallthrough statement starts with __attribute__ as well.
 @@ -150,31 +150,31 @@ unsigned long sizes =
     sizeof(const typeof(bool)) +
     sizeof(const typeof(plain_char)) +
     sizeof(const typeof(signed_char)) +
     sizeof(const typeof(unsigned_char)) +
     sizeof(const typeof(signed_short)) +
     sizeof(const typeof(unsigned_short)) +
     sizeof(const typeof(signed_int)) +
     sizeof(const typeof(unsigned_int)) +
     sizeof(const typeof(signed_long)) +
     sizeof(const typeof(unsigned_long)) +
     sizeof(const typeof(unnamed_struct));
 /* expect+2: error: old style declaration; add 'int' [1] */
-/* expect+1: syntax error 'int' [249] */
+/* expect+1: error: syntax error 'int' [249] */
 thread int thread_int;
 __thread int thread_int;
 /* expect+2: error: old style declaration; add 'int' [1] */
-/* expect+1: syntax error 'int' [249] */
+/* expect+1: error: syntax error 'int' [249] */
 __thread__ int thread_int;
 /* expect+4: error: old style declaration; add 'int' [1] */
 /* expect+2: warning: static function 'cover_func_declarator' unused [236] */
 static
 cover_func_declarator(void)
+{
+}
 /*
  * Before decl.c 1.268 from 2022-04-03, lint ran into an assertion failure for
  * "elsz > 0" in 'length'.
  */

--- src/tests/usr.bin/xlint/lint1/decl_direct_abstract.c 2022/04/01 23:16:32	1.6
+++ src/tests/usr.bin/xlint/lint1/decl_direct_abstract.c 2022/06/17 18:54:53	1.7

 @@ -1,75 +1,75 @@
-/*	$NetBSD: decl_direct_abstract.c,v 1.6 2022/04/01 23:16:32 rillig Exp $	*/
+/*	$NetBSD: decl_direct_abstract.c,v 1.7 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "decl_direct_abstract.c"
 /*
  * Test parsing of direct-abstract-declarator (C99 6.7.6), which are a tricky
  * part of the C standard since they require lookahead and are so complicated
  * that GCC's parser dedicates 34 lines of comments to this topic.
+ *
  * See msg_155.c.
  */
 /*
  * The following tests do not use int, to avoid confusion with the implicit
  * return type.
  */
 char func0001(short (*)(long));
 /* GCC says 'char (*)(short int (*)(long int))' */
 /* Clang says 'char (short (*)(long))' */
 /* cdecl says 'function (pointer to function (long) returning short) returning char' */
-/* expect+1: 'pointer to function(pointer to function(long) returning short) returning char' */
+/* expect+1: error: cannot initialize 'double' from 'pointer to function(pointer to function(long) returning short) returning char' [185] */
 double type_of_func0001 = func0001;
 char func0002(short *(long));
 /* GCC says 'char (*)(short int * (*)(long int))' */
 /* Clang says 'char (short *(*)(long))' */
 /* cdecl says 'syntax error' */
 /* FIXME: lint is wrong, it discards the 'short *' */
-/* expect+1: 'pointer to function(long) returning char' */
+/* expect+1: error: cannot initialize 'double' from 'pointer to function(long) returning char' [185] */
 double type_of_func0002 = func0002;
 void c99_6_7_6_example_a(int);
 void c99_6_7_6_example_b(int *);
 void c99_6_7_6_example_c(int *[3]);
 void c99_6_7_6_example_d(int (*)[3]);
 void c99_6_7_6_example_e(int (*)[*]);
 void c99_6_7_6_example_f(int *());
 void c99_6_7_6_example_g(int (*)(void));
 void c99_6_7_6_example_h(int (*const[])(unsigned int, ...));
 struct incompatible {
 	int member;
 } x;
-/* expect+1: 'pointer to function(int) returning void' */
+/* expect+1: ... 'pointer to function(int) returning void' ... */
 double type_of_c99_6_7_6_example_a = c99_6_7_6_example_a;
-/* expect+1: 'pointer to function(pointer to int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to int) returning void' ... */
 double type_of_c99_6_7_6_example_b = c99_6_7_6_example_b;
-/* expect+1: 'pointer to function(pointer to pointer to int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to pointer to int) returning void' ... */
 double type_of_c99_6_7_6_example_c = c99_6_7_6_example_c;
-/* expect+1: 'pointer to function(pointer to array[3] of int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to array[3] of int) returning void' ... */
 double type_of_c99_6_7_6_example_d = c99_6_7_6_example_d;
-/* expect+1: 'pointer to function(pointer to array[unknown_size] of int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to array[unknown_size] of int) returning void' ... */
 double type_of_c99_6_7_6_example_e = c99_6_7_6_example_e;
 /* Wrong type before decl.c 1.256 from 2022-04-01. */
-/* expect+1: 'pointer to function(pointer to function() returning pointer to int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to function() returning pointer to int) returning void' ... */
 double type_of_c99_6_7_6_example_f = c99_6_7_6_example_f;
-/* expect+1: 'pointer to function(pointer to function(void) returning int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to function(void) returning int) returning void' ... */
 double type_of_c99_6_7_6_example_g = c99_6_7_6_example_g;
-/* expect+1: 'pointer to function(pointer to const pointer to function(unsigned int, ...) returning int) returning void' */
+/* expect+1: ... 'pointer to function(pointer to const pointer to function(unsigned int, ...) returning int) returning void' ... */
 double type_of_c99_6_7_6_example_h = c99_6_7_6_example_h;
 void int_array(int[]);
 void int_array_3(int[3]);
 /* supported since cgram.y 1.363 from 2021-09-14 */
 void int_array_ast(int[*]);
 /* expect+1: error: null dimension [17] */
 void int_array_7_array(int[7][]);
 void int_array_7_array_3(int[7][3]);
 /* expect+1: error: null dimension [17] */
 void int_array_7_array_ast(int[7][*]);
 void int_array_array(int[][7]);

--- src/tests/usr.bin/xlint/lint1/msg_343.c 2022/06/17 06:59:16	1.6
+++ src/tests/usr.bin/xlint/lint1/msg_343.c 2022/06/17 18:54:53	1.7

 @@ -1,49 +1,49 @@
-/*	$NetBSD: msg_343.c,v 1.6 2022/06/17 06:59:16 rillig Exp $	*/
+/*	$NetBSD: msg_343.c,v 1.7 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_343.c"
 /* Test for message: static array size is a C11 extension [343] */
 /* lint1-flags: -Sw */
 void takes_int_pointer(int []);
 void takes_int_pointer_with_ignored_size(int [3]);
 /* expect+1: error: static array size is a C11 extension [343] */
 void takes_int_array(int[static 3]);
-/* expect+1: syntax error '3' */
+/* expect+1: error: syntax error '3' [249] */
 void takes_volatile_int_array(int[volatile 3]);
 int
 returns_int_pointer(int a[])
+{
 	return a[0];
+}
 int
 returns_int_pointer_with_ignored_size(int a[3])
+{
 	return a[0];
+}
 int
 /* expect+1: error: static array size is a C11 extension [343] */
 returns_int_array(int a[static 3])
+{
 	return a[0];
+}
 int
-/* expect+1: syntax error '3' */
+/* expect+1: error: syntax error '3' [249] */
 returns_volatile_int_array(int a[volatile 3])
+{
-	/* expect+2: cannot dereference non-pointer type */
+	/* expect+2: error: cannot dereference non-pointer type [96] */
-	/* expect+1: expects to return value */
+	/* expect+1: ... expects to return value [214] */
 	return a[0];
+}
 /*
  * This triggers the "Bad attribute", but for some reason, that custom error
  * message does not make it into the actual diagnostic.
  */
 /* expect+2: error: syntax error ']' [249] */
 /* expect+1: error: static array size is a C11 extension [343] */
 void invalid_storage_class(int a[const typedef 3]);

--- src/tests/usr.bin/xlint/lint1/decl_enum_c90.c 2021/07/15 21:00:05	1.1
+++ src/tests/usr.bin/xlint/lint1/decl_enum_c90.c 2022/06/17 18:54:53	1.2

 @@ -1,13 +1,13 @@
-/*	$NetBSD: decl_enum_c90.c,v 1.1 2021/07/15 21:00:05 rillig Exp $	*/
+/*	$NetBSD: decl_enum_c90.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "decl_enum_c90.c"
 /*
  * Tests for enum declarations in C90 mode.
  */
 /* lint1-flags: -sw */
 enum {
 	A,
 };
-/* expect-1: trailing ',' prohibited in enum declaration [54] */
+/* expect-1: error: trailing ',' prohibited in enum declaration [54] */

--- src/tests/usr.bin/xlint/lint1/expr_binary_trad.c 2021/08/01 16:29:28	1.1
+++ src/tests/usr.bin/xlint/lint1/expr_binary_trad.c 2022/06/17 18:54:53	1.2

 @@ -1,67 +1,67 @@
-/*	$NetBSD: expr_binary_trad.c,v 1.1 2021/08/01 16:29:28 rillig Exp $	*/
+/*	$NetBSD: expr_binary_trad.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "expr_binary_trad.c"
 /*
  * Test binary operators in traditional C.
  */
 /* lint1-flags: -tw */
 struct incompatible {		/* just to generate the error message */
 	int member;
 };
 struct incompatible sink;
 /*
  * Test the usual arithmetic conversions.
+ *
  * C99 6.3.1.8 "Usual arithmetic conversions"
  */
 void
 cover_balance()
+{
-	/* expect+1: 'pointer to char' */
+	/* expect+1: ... 'pointer to char' ... */
 	sink = (char *)0 + 0;
-	/* expect+1: 'pointer to char' */
+	/* expect+1: ... 'pointer to char' ... */
 	sink = 0 + (char *)0;
-	/* expect+1: 'int' */
+	/* expect+1: ... 'int' ... */
 	sink = 1 + 1;
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = 0.0 + 0;
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = 0 + 0.0;
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = 0.0 + (float)0.0;
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = (float)0.0 + 0.0;
 	/*
 	 * In traditional C, 'float' gets promoted to 'double' before
 	 * applying the usual arithmetic conversions; see 'promote'.
 	 */
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = (float)0.0 + 0;
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink = 0 + (float)0.0;
-	/* expect+1: 'unsigned long' */
+	/* expect+1: ... 'unsigned long' ... */
 	sink = (unsigned long)0 + 0;
-	/* expect+1: 'unsigned long' */
+	/* expect+1: ... 'unsigned long' ... */
 	sink = 0 + (unsigned long)0;
-	/* expect+1: 'unsigned long' */
+	/* expect+1: ... 'unsigned long' ... */
 	sink = (unsigned long)0 + (long)0;
-	/* expect+1: 'unsigned long' */
+	/* expect+1: ... 'unsigned long' ... */
 	sink = (long)0 + (unsigned long)0;
 	/*
 	 * In traditional C, if one of the operands is unsigned, the result
 	 * is unsigned as well.
 	 */
-	/* expect+1: 'unsigned long' */
+	/* expect+1: ... 'unsigned long' ... */
 	sink = (unsigned)0 + (long)0;
+}

--- src/tests/usr.bin/xlint/lint1/lex_integer_binary.c 2021/07/13 19:38:10	1.1
+++ src/tests/usr.bin/xlint/lint1/lex_integer_binary.c 2022/06/17 18:54:53	1.2

 @@ -1,30 +1,30 @@
-/*	$NetBSD: lex_integer_binary.c,v 1.1 2021/07/13 19:38:10 rillig Exp $	*/
+/*	$NetBSD: lex_integer_binary.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_integer_binary.c"
 /*
  * Test for parsing binary integer literals in non-GCC mode.
  * As of C11, binary integer literals are not supported.
  * Neither are underscores in integer literals.
  */
 /* Remove the default -g flag. */
 /* lint1-flags: -Ac11 -w */
 void sink(unsigned int);
 void
 binary_literal(void)
+{
 	/*
 	 * Binary integer literals are a GCC extension, but lint allows them
 	 * even in non-GCC mode.
 	 */
 	sink(0b1111000001011010);
 	/*
 	 * Even though it would be useful for binary literals, GCC does not
 	 * support underscores to separate the digit groups.
 	 */
-	/* expect+1: syntax error '_0000_0101_1010' [249] */
+	/* expect+1: error: syntax error '_0000_0101_1010' [249] */
 	sink(0b1111_0000_0101_1010);
+}

--- src/tests/usr.bin/xlint/lint1/msg_341.c 2021/04/05 02:05:47	1.1
+++ src/tests/usr.bin/xlint/lint1/msg_341.c 2022/06/17 18:54:53	1.2

 @@ -1,48 +1,48 @@
-/*	$NetBSD: msg_341.c,v 1.1 2021/04/05 02:05:47 rillig Exp $	*/
+/*	$NetBSD: msg_341.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_341.c"
 // Test for message: argument to '%s' must be 'unsigned char' or EOF, not '%s' [341]
 /*
  * Ensure that the functions from <ctype.h> are called with the correct
  * argument.
  */
 /* NetBSD 9.99.81, <ctype.h> */
 extern const unsigned short *_ctype_tab_;
 extern const short *_tolower_tab_;
 extern const short *_toupper_tab_;
 int isspace(int);
 void sink(int);
 void
 function_call_char(char c)
+{
-	/* expect+1: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' */
+	/* expect+1: warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341] */
 	(isspace)(c);
 	/* This is the only allowed form. */
 	isspace((unsigned char)c);
 	/* The cast to 'int' is redundant, it doesn't hurt though. */
 	isspace((int)(unsigned char)c);
-	/* expect+1: argument to 'isspace' must be cast to 'unsigned char', not to 'int' */
+	/* expect+1: warning: argument to 'isspace' must be cast to 'unsigned char', not to 'int' [342] */
 	isspace((int)c);
-	/* expect+1: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' */
+	/* expect+1: warning: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' [342] */
 	isspace((unsigned int)c);
+}
 /*
  * If the expression starts with type 'unsigned char', it can be cast to any
  * other type.  Chances are low enough that the cast is to 'char', which would
  * be the only bad type.
  */
 void
 function_call_unsigned_char(unsigned char c)
+{
 	(isspace)(c);
 @@ -53,25 +53,25 @@ function_call_unsigned_char(unsigned cha
 /* When used in a loop of fgetc, the type is already 'int'.  That's fine. */
 void
 function_call_int(int c)
+{
 	isspace(c);
+}
 void
 macro_invocation_NetBSD(char c)
+{
-	/* expect+1: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' [341] */
 	sink(((int)((_ctype_tab_ + 1)[(c)] & 0x0040)));
 	/* This is the only allowed form. */
 	sink(((int)((_ctype_tab_ + 1)[((unsigned char)c)] & 0x0040)));
-	/* expect+1: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' [342] */
 	sink(((int)((_ctype_tab_ + 1)[((int)c)] & 0x0040)));
-	/* expect+1: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' [342] */
 	sink(((int)((_ctype_tab_ + 1)[((unsigned int)c)] & 0x0040)));
+}

--- src/tests/usr.bin/xlint/lint1/msg_344.c 2021/05/16 11:11:37	1.1
+++ src/tests/usr.bin/xlint/lint1/msg_344.c 2022/06/17 18:54:53	1.2

 @@ -1,24 +1,24 @@
-/*	$NetBSD: msg_344.c,v 1.1 2021/05/16 11:11:37 rillig Exp $	*/
+/*	$NetBSD: msg_344.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_344.c"
 // Test for message: bit-field of type plain 'int' has implementation-defined signedness [344]
 /* lint1-extra-flags: -p */
 /*
  * C90 3.5.2.1 allows 'int', 'signed int', 'unsigned int' as bit-field types.
+ *
  * C99 6.7.2.1 significantly changed the wording of the allowable types for
  * bit-fields.  For example, 6.7.2.1p4 does not mention plain 'int' at all.
  * The rationale for C99 6.7.2.1 mentions plain 'int' though, and it would
  * have broken a lot of existing code to disallow plain 'int' as a bit-field
  * type.  Footnote 104 explicitly mentions plain 'int' as well and it even
  * allows typedef-types for bit-fields.
  */
 struct example {
-	/* expect+1: 344 */
+	/* expect+1: warning: bit-field of type plain 'int' has implementation-defined signedness [344] */
 	int plain_int: 1;
 	signed int signed_int: 1;
 	unsigned int unsigned_int: 1;
 };

--- src/tests/usr.bin/xlint/lint1/parse_stmt_error.c 2021/07/25 09:29:20	1.1
+++ src/tests/usr.bin/xlint/lint1/parse_stmt_error.c 2022/06/17 18:54:53	1.2

 @@ -1,26 +1,26 @@
-/*	$NetBSD: parse_stmt_error.c,v 1.1 2021/07/25 09:29:20 rillig Exp $	*/
+/*	$NetBSD: parse_stmt_error.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "parse_stmt_error.c"
 /*
  * Test parsing of errors in selection statements (if, switch).
  */
 void do_nothing(void);
 void
 cover_selection_statement_else(_Bool cond)
+{
 	if (cond)
 		do_nothing();
 	else
-		/* expect+1: syntax error ']' [249] */
+		/* expect+1: error: syntax error ']' [249] */
 		];
+}
 void
 cover_selection_statement_switch(int x)
+{
 	switch (x)
-		/* expect+1: syntax error ']' [249] */
+		/* expect+1: error: syntax error ']' [249] */
 		];
+}

--- src/tests/usr.bin/xlint/lint1/parse_stmt_iter_error.c 2021/07/25 09:29:20	1.1
+++ src/tests/usr.bin/xlint/lint1/parse_stmt_iter_error.c 2022/06/17 18:54:53	1.2

	@@ -1,32 +1,32 @@		@@ -1,32 +1,32 @@
1	/* $NetBSD: parse_stmt_iter_error.c,v 1.1 2021/07/25 09:29:20 rillig Exp $ */	1	/* $NetBSD: parse_stmt_iter_error.c,v 1.2 2022/06/17 18:54:53 rillig Exp $ */
2	# 3 "parse_stmt_iter_error.c"	2	# 3 "parse_stmt_iter_error.c"
3		3
4	/*	4	/*
5	* Test parsing of errors in iteration statements (while, do, for).	5	* Test parsing of errors in iteration statements (while, do, for).
6	*/	6	*/
7		7
8	void do_nothing(void);	8	void do_nothing(void);
9		9
10	void	10	void
11	cover_iteration_statement_while(_Bool cond)	11	cover_iteration_statement_while(_Bool cond)
12	{	12	{
13	while (cond)	13	while (cond)
14	/* expect+1: syntax error ']' [249] */	14	/* expect+1: error: syntax error ']' [249] */
15	];	15	];
16	}	16	}
17		17
18	void	18	void
19	cover_iteration_statement_do(void)	19	cover_iteration_statement_do(void)
20	{	20	{
21	do	21	do
22	/* expect+1: syntax error ']' [249] */	22	/* expect+1: error: syntax error ']' [249] */
23	];	23	];
24	}	24	}
25		25
26	void	26	void
27	cover_iteration_statement_for(void)	27	cover_iteration_statement_for(void)
28	{	28	{
29	for (int i = 0; i < 10; i++)	29	for (int i = 0; i < 10; i++)
30	/* expect+1: syntax error ']' [249] */	30	/* expect+1: error: syntax error ']' [249] */
31	];	31	];
32	}	32	}

--- src/tests/usr.bin/xlint/lint1/stmt_goto.c 2021/07/14 20:39:13	1.1
+++ src/tests/usr.bin/xlint/lint1/stmt_goto.c 2022/06/17 18:54:53	1.2

 @@ -1,26 +1,26 @@
-/*	$NetBSD: stmt_goto.c,v 1.1 2021/07/14 20:39:13 rillig Exp $	*/
+/*	$NetBSD: stmt_goto.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "stmt_goto.c"
 /*
  * Tests for the 'goto' statement.
  */
-/* expect+1: syntax error 'goto' [249] */
+/* expect+1: error: syntax error 'goto' [249] */
 goto invalid_at_top_level;
 void
 function(void)
+{
 	goto label;
 label:
-	/* expect+1: syntax error '"' [249] */
+	/* expect+1: error: syntax error '"' [249] */
 	goto "string";
 	/* Reset the error handling of the parser. */
 	goto ok;
 ok:
 	/* Numeric labels work in Pascal, but not in C. */
-	/* expect+1: syntax error '12345' [249] */
+	/* expect+1: error: syntax error '12345' [249] */
 	goto 12345;
+}

--- src/tests/usr.bin/xlint/lint1/stmt_if.c 2021/07/11 18:58:13	1.1
+++ src/tests/usr.bin/xlint/lint1/stmt_if.c 2022/06/17 18:54:53	1.2

 @@ -1,28 +1,28 @@
-/*	$NetBSD: stmt_if.c,v 1.1 2021/07/11 18:58:13 rillig Exp $	*/
+/*	$NetBSD: stmt_if.c,v 1.2 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "stmt_if.c"
 /*
  * Test parsing of 'if' statements.
  */
 void println(const char *);
 void
 dangling_else(int x)
+{
 	if (x > 0)
 		if (x > 10)
 			println("> 10");
 		/* This 'else' is bound to the closest unfinished 'if'. */
 		else
 			println("> 0");
 	/*
 	 * If the above 'else' were bound to the other 'if', the next 'else'
 	 * would have no corresponding 'if', resulting in a syntax error.
 	 */
 	else
 		println("not positive");
-	/* expect+1: syntax error 'else' [249] */
+	/* expect+1: error: syntax error 'else' [249] */
 	else
 		println("syntax error");
+}

--- src/tests/usr.bin/xlint/lint1/decl_struct_member.c 2022/01/15 14:22:03	1.14
+++ src/tests/usr.bin/xlint/lint1/decl_struct_member.c 2022/06/17 18:54:53	1.15

 @@ -1,14 +1,14 @@
-/*	$NetBSD: decl_struct_member.c,v 1.14 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: decl_struct_member.c,v 1.15 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "decl_struct_member.c"
 struct multi_attributes {
 	__attribute__((deprecated))
 	__attribute__((deprecated))
 	__attribute__((deprecated))
 	int deprecated;
 };
 struct cover_begin_type_specifier_qualifier_list {
 	int m1;
 	__attribute__((deprecated)) int m2;
 	const int m3;
 @@ -77,14 +77,14 @@ struct array_of_bit_fields {
  * Before decl.c 1.188 from 2021-06-20, lint ran into a segmentation fault.
  */
 struct {
 	/* expect+1: error: syntax error '0' [249] */
 	char a(_)0
 /*
  * Before cgram.y 1.328 from 2021-07-15, lint ran into an assertion failure
  * at the closing semicolon:
+ *
  * assertion "t == NOTSPEC" failed in end_type at decl.c:774
  */
 };
-/* expect+1: cannot recover from previous errors */
+/* expect+1: error: cannot recover from previous errors [224] */

--- src/tests/usr.bin/xlint/lint1/expr_binary.c 2021/08/01 14:51:41	1.5
+++ src/tests/usr.bin/xlint/lint1/expr_binary.c 2022/06/17 18:54:53	1.6

 @@ -1,129 +1,129 @@
-/*	$NetBSD: expr_binary.c,v 1.5 2021/08/01 14:51:41 rillig Exp $	*/
+/*	$NetBSD: expr_binary.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "expr_binary.c"
 /*
  * Test binary operators.
  */
 /* lint1-only-if: lp64 */
 struct incompatible {		/* just to generate the error message */
 	int member;
 };
 void sink(struct incompatible);
 /*
  * Test the usual arithmetic conversions.
+ *
  * C99 6.3.1.8 "Usual arithmetic conversions"
  */
 void
 cover_balance(void)
+{
-	/* expect+1: 'pointer to void' */
+	/* expect+1: ... 'pointer to void' ... */
 	sink((void *)0 + 0);
-	/* expect+1: 'pointer to void' */
+	/* expect+1: ... 'pointer to void' ... */
 	sink(0 + (void *)0);
-	/* expect+1: 'int' */
+	/* expect+1: ... 'int' ... */
 	sink(1 + 1);
-	/* expect+1: 'const int' */
+	/* expect+1: ... 'const int' ... */
 	sink((const int)1 + (volatile int)1);
-	/* expect+1: 'volatile int' */
+	/* expect+1: ... 'volatile int' ... */
 	sink((volatile int)1 + (const int)1);
 	long double _Complex cldbl = 0.0;
 	double _Complex cdbl = 0.0;
 	float _Complex cflt = 0.0f;
 	/* expect+1: error: invalid type for _Complex [308] */
 	_Complex invalid = 0.0;
-	/* expect+1: 'long double _Complex' */
+	/* expect+1: ... 'long double _Complex' ... */
 	sink(cldbl + 0);
-	/* expect+1: 'long double _Complex' */
+	/* expect+1: ... 'long double _Complex' ... */
 	sink(0 + cldbl);
-	/* expect+1: 'long double _Complex' */
+	/* expect+1: ... 'long double _Complex' ... */
 	sink(cldbl + cdbl);
-	/* expect+1: 'long double _Complex' */
+	/* expect+1: ... 'long double _Complex' ... */
 	sink(cdbl + cldbl);
-	/* expect+1: 'double _Complex' */
+	/* expect+1: ... 'double _Complex' ... */
 	sink(cdbl + 0);
-	/* expect+1: 'double _Complex' */
+	/* expect+1: ... 'double _Complex' ... */
 	sink(0 + cdbl);
-	/* expect+1: 'double _Complex' */
+	/* expect+1: ... 'double _Complex' ... */
 	sink(cdbl + cflt);
-	/* expect+1: 'double _Complex' */
+	/* expect+1: ... 'double _Complex' ... */
 	sink(cflt + cdbl);
-	/* expect+1: 'float _Complex' */
+	/* expect+1: ... 'float _Complex' ... */
 	sink(cflt + 0);
-	/* expect+1: 'float _Complex' */
+	/* expect+1: ... 'float _Complex' ... */
 	sink(0 + cflt);
-	/* expect+1: 'float _Complex' */
+	/* expect+1: ... 'float _Complex' ... */
 	sink(cflt + (__uint128_t)0);
-	/* expect+1: 'float _Complex' */
+	/* expect+1: ... 'float _Complex' ... */
 	sink((__uint128_t)0 + cflt);
 	/*
 	 * The type specifier '_Complex' is only used during parsing, it does
 	 * not make it to the expression.
 	 */
-	/* expect+1: 'double _Complex' */
+	/* expect+1: ... 'double _Complex' ... */
 	sink(invalid + 0);
-	/* expect+1: 'long double' */
+	/* expect+1: ... 'long double' ... */
 	sink(0.0L + 0);
-	/* expect+1: 'long double' */
+	/* expect+1: ... 'long double' ... */
 	sink(0 + 0.0L);
-	/* expect+1: 'long double' */
+	/* expect+1: ... 'long double' ... */
 	sink(0.0L + 0.0);
-	/* expect+1: 'long double' */
+	/* expect+1: ... 'long double' ... */
 	sink(0.0 + 0.0L);
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink(0.0 + 0);
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink(0 + 0.0);
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink(0.0 + 0.0f);
-	/* expect+1: 'double' */
+	/* expect+1: ... 'double' ... */
 	sink(0.0f + 0.0);
-	/* expect+1: 'float' */
+	/* expect+1: ... 'float' ... */
 	sink(0.0f + 0);
-	/* expect+1: 'float' */
+	/* expect+1: ... 'float' ... */
 	sink(0 + 0.0f);
-	/* expect+1: 'float' */
+	/* expect+1: ... 'float' ... */
 	sink(0.0f + (__uint128_t)0);
-	/* expect+1: 'float' */
+	/* expect+1: ... 'float' ... */
 	sink((__uint128_t)0 + 0.0f);
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0ULL + 0);
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0 + 0ULL);
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0ULL + 0LL);
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0LL + 0ULL);
 	/* If the bit-width is the same, prefer the unsigned variant. */
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0UL + 0LL);
-	/* expect+1: 'unsigned long long' */
+	/* expect+1: ... 'unsigned long long' ... */
 	sink(0LL + 0UL);
 	/*
 	 * Ensure that __int128_t is listed in the integer ranks.  This table
 	 * only becomes relevant when both operands have the same width.
 	 */
-	/* expect+1: '__uint128_t' */
+	/* expect+1: ... '__uint128_t' ... */
 	sink((__uint128_t)1 + (__int128_t)1);
-	/* expect+1: '__uint128_t' */
+	/* expect+1: ... '__uint128_t' ... */
 	sink((__int128_t)1 + (__uint128_t)1);
+}

--- src/tests/usr.bin/xlint/lint1/gcc_init_compound_literal.c 2022/06/11 11:52:13	1.5
+++ src/tests/usr.bin/xlint/lint1/gcc_init_compound_literal.c 2022/06/17 18:54:53	1.6

 @@ -1,14 +1,14 @@
-/*	$NetBSD: gcc_init_compound_literal.c,v 1.5 2022/06/11 11:52:13 rillig Exp $	*/
+/*	$NetBSD: gcc_init_compound_literal.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_init_compound_literal.c"
 /*
  * C99 says in 6.7.8p4:
+ *
  *	All the expressions in an initializer for an object that has static
  *	storage duration shall be constant expressions or string literals.
+ *
  * The term "constant expression" is defined in C99 6.6, where 6.6p9 allows
  * "constant expressions" in initializers to also be an "address constant".
  * Using these address constants, it is possible to reference an unnamed
  * object created by a compound literal (C99 6.5.2.5), using either an
  * explicit '&' or the implicit array-to-pointer conversion from C99 6.3.2.1.
 @@ -27,27 +27,27 @@ const struct {
 	},
 };
 struct node {
 	int num;
 	struct node *left;
 	struct node *right;
 };
 /*
  * Initial tree for representing the decisions in the classic number guessing
  * game often used in teaching the basics of programming.
  */
-/* expect+1: static variable 'guess' unused */
+/* expect+1: warning: static variable 'guess' unused [226] */
 static const struct node guess = {
 ,
 	&(struct node){
 ,
 		&(struct node){
 ,
 			(void *)0,
 			(void *)0,
 		},
 		&(struct node){
 ,
 			(void *)0,
 			(void *)0,

--- src/tests/usr.bin/xlint/lint1/lex_char.c 2022/04/01 21:12:42	1.5
+++ src/tests/usr.bin/xlint/lint1/lex_char.c 2022/06/17 18:54:53	1.6

 @@ -1,50 +1,50 @@
-/*	$NetBSD: lex_char.c,v 1.5 2022/04/01 21:12:42 rillig Exp $	*/
+/*	$NetBSD: lex_char.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_char.c"
 /*
  * Tests for lexical analysis of character constants.
+ *
  * C99 6.4.4.4 "Character constants"
  */
 void sink(char);
 void
 test(void)
+{
-	/* expect+1: empty character constant */
+	/* expect+1: error: empty character constant [73] */
 	sink('');
 	sink('a');
 	sink('\0');
 	/* UTF-8 */
-	/* expect+2: multi-character character constant */
+	/* expect+2: warning: multi-character character constant [294] */
-	/* expect+1: conversion of 'int' to 'char' is out of range */
+	/* expect+1: warning: conversion of 'int' to 'char' is out of range, arg #1 [295] */
 	sink('ä');
 	/* GCC extension */
-	/* expect+1: dubious escape \e */
+	/* expect+1: warning: dubious escape \e [79] */
 	sink('\e');
 	/* since C99 */
 	sink('\x12');
 	/* octal */
 	sink('\177');
-	/* expect+1: empty character constant */
+	/* expect+1: error: empty character constant [73] */
 	sink('');
 	/* U+0007 alarm/bell */
 	sink('\a');
 	/* U+0008 backspace */
 	sink('\b');
 	/* U+0009 horizontal tabulation */
 	sink('\t');
 	/* U+000A line feed */
 	sink('\n');

--- src/tests/usr.bin/xlint/lint1/msg_034.c 2021/05/16 11:11:37	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_034.c 2022/06/17 18:54:53	1.6

 @@ -1,28 +1,28 @@
-/*	$NetBSD: msg_034.c,v 1.5 2021/05/16 11:11:37 rillig Exp $	*/
+/*	$NetBSD: msg_034.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_034.c"
 // Test for message: nonportable bit-field type '%s' [34]
 /* No -g since GCC allows all integer types as bit-fields. */
 /* lint1-flags: -S -p -w */
 /*
  * C90 3.5.2.1 allows 'int', 'signed int', 'unsigned int' as bit-field types.
+ *
  * C99 6.7.2.1 significantly changed the wording of the allowable types for
  * bit-fields.  For example, 6.7.2.1p4 does not mention plain 'int' at all.
  * The rationale for C99 6.7.2.1 mentions plain int though, and it would have
  * broken a lot of existing code to disallow plain 'int' as a bit-field type.
  * Footnote 104 explicitly mentions plain 'int' as well and it even allows
  * typedef-types for bit-fields.
  */
 struct example {
-	/* expect+1: 34 */
+	/* expect+1: warning: nonportable bit-field type 'unsigned short' [34] */
 	unsigned short ushort: 1;
-	/* expect+1: 344 */
+	/* expect+1: warning: bit-field of type plain 'int' has implementation-defined signedness [344] */
 	int plain_int: 1;
 	signed int signed_int: 1;
 	unsigned int portable: 1;
 };

--- src/tests/usr.bin/xlint/lint1/msg_066.c 2021/08/26 19:23:25	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_066.c 2022/06/17 18:54:53	1.6

 @@ -1,16 +1,16 @@
-/*	$NetBSD: msg_066.c,v 1.5 2021/08/26 19:23:25 rillig Exp $	*/
+/*	$NetBSD: msg_066.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_066.c"
 // Test for message: syntax requires ';' after last struct/union member [66]
 /* This message is not used. */
 /*
  * This message was removed in cgram.y 1.328 from 2021-07-15 because all
  * C standards and even K&R require a semicolon.
  */
 struct number {
 	int value
 };
-/* expect-1: syntax error '}' [249] */
+/* expect-1: error: syntax error '}' [249] */
 /* expect+1: error: cannot recover from previous errors [224] */

--- src/tests/usr.bin/xlint/lint1/msg_077.c 2022/06/15 20:18:31	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_077.c 2022/06/17 18:54:53	1.6

 @@ -1,27 +1,27 @@
-/*	$NetBSD: msg_077.c,v 1.5 2022/06/15 20:18:31 rillig Exp $	*/
+/*	$NetBSD: msg_077.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_077.c"
 /* Test for message: bad octal digit %c [77] */
 /* lint1-flags: -tw */
 /* expect+1: warning: bad octal digit 8 [77] */
 char single_digit = '\8';
 /*
  * Before lex.c 1.47 from 2021-06-29, lint intended to detect a "bad octal
  * digit" following good octal digits, but the corresponding code had an
  * unsatisfiable guard clause.
+ *
  * The C Reference Manual 1978, 2.4.3 "Character constants" does not mention
  * non-octal digits, therefore this code must have been due to a particular
  * C compiler's interpretation.  It's even wrong according to the Reference
  * Manual to interpret '\088' as anything else than a malformed character
  * literal.
+ *
  * That code has been removed since nobody runs lint in traditional C mode
  * anyway.
  * https://mail-index.netbsd.org/tech-toolchain/2021/03/16/msg003933.html
  */
-/* expect+1: multi-character character constant [294] */
+/* expect+1: warning: multi-character character constant [294] */
 char several_digits = '\08';

--- src/tests/usr.bin/xlint/lint1/msg_118.c 2021/05/04 19:57:56	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_118.c 2022/06/17 18:54:53	1.6

	@@ -1,30 +1,30 @@		@@ -1,30 +1,30 @@
1	/* $NetBSD: msg_118.c,v 1.5 2021/05/04 19:57:56 rillig Exp $ */	1	/* $NetBSD: msg_118.c,v 1.6 2022/06/17 18:54:53 rillig Exp $ */
2	# 3 "msg_118.c"	2	# 3 "msg_118.c"
3		3
4	/* Test for message: semantics of '%s' change in ANSI C; use explicit cast [118] */	4	/* Test for message: semantics of '%s' change in ANSI C; use explicit cast [118] */
5		5
6	/* lint1-flags: -hw */	6	/* lint1-flags: -hw */
7		7
8	int	8	int
9	int_shl_uint(int left, unsigned int right)	9	int_shl_uint(int left, unsigned int right)
10	{	10	{
11	return left << right;	11	return left << right;
12	}	12	}
13		13
14	int	14	int
15	int_shr_uint(int left, unsigned int right)	15	int_shr_uint(int left, unsigned int right)
16	{	16	{
17	/* expect+1: semantics of '>>' change in ANSI C */	17	/* expect+1: warning: semantics of '>>' change in ANSI C; use explicit cast [118] */
18	return left >> right;	18	return left >> right;
19	}	19	}
20		20
21	int	21	int
22	int_shl_int(int left, int right)	22	int_shl_int(int left, int right)
23	{	23	{
24	return left << right;	24	return left << right;
25	}	25	}
26		26
27	/*	27	/*
28	* The behavior of typeok_shl can only be triggered on 64-bit platforms, or	28	* The behavior of typeok_shl can only be triggered on 64-bit platforms, or
29	* in C99 mode, and the above tests require C90 mode.	29	* in C99 mode, and the above tests require C90 mode.
30	*	30	*

--- src/tests/usr.bin/xlint/lint1/msg_189.c 2021/08/26 19:23:25	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_189.c 2022/06/17 18:54:53	1.6

 @@ -1,21 +1,21 @@
-/*	$NetBSD: msg_189.c,v 1.5 2021/08/26 19:23:25 rillig Exp $	*/
+/*	$NetBSD: msg_189.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_189.c"
 /* Test for message: assignment of struct/union illegal in traditional C [189] */
 /* This message is not used. */
 /* lint1-flags: -tw */
 struct s {
 	int member;
 };
 void
 example()
+{
 	struct s a, b;
 	a.member = 3;
 	b = a;			/* message 189 is not triggered anymore */
-	/* expect-1: 'b' set but not used in function 'example' */
+	/* expect-1: warning: 'b' set but not used in function 'example' [191] */
+}

--- src/tests/usr.bin/xlint/lint1/msg_232.c 2021/07/11 19:30:56	1.5
+++ src/tests/usr.bin/xlint/lint1/msg_232.c 2022/06/17 18:54:53	1.6

 @@ -1,15 +1,15 @@
-/*	$NetBSD: msg_232.c,v 1.5 2021/07/11 19:30:56 rillig Exp $	*/
+/*	$NetBSD: msg_232.c,v 1.6 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_232.c"
 // Test for message: label '%s' unused in function '%s' [232]
 void
 example(void)
+{
 	goto used_label;
-	/* expect+1: label 'unused_label' unused in function 'example' [232] */
+	/* expect+1: warning: label 'unused_label' unused in function 'example' [232] */
 unused_label:
 	return;
 used_label:
 	return;
+}

--- src/tests/usr.bin/xlint/lint1/expr_precedence.c 2021/11/16 17:41:23	1.8
+++ src/tests/usr.bin/xlint/lint1/expr_precedence.c 2022/06/17 18:54:53	1.9

 @@ -1,14 +1,14 @@
-/*	$NetBSD: expr_precedence.c,v 1.8 2021/11/16 17:41:23 rillig Exp $	*/
+/*	$NetBSD: expr_precedence.c,v 1.9 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "expr_precedence.c"
 /*
  * Tests for the precedence among operators.
  */
 int var;
 /*
  * An initializer needs an assignment-expression; the comma must be
  * interpreted as a separator, not an operator.
  */
 /* expect+1: error: syntax error '4' [249] */
 @@ -21,27 +21,27 @@ int init_syntactically_ok = var = 1 ? 2
  * The arguments of __attribute__ must be constant-expression, as assignments
  * don't make sense at that point.
  */
 void __attribute__((format(printf,
     /*
      * Inside of __attribute__((...)), symbol lookup works differently.  For
      * example, 'printf' is a keyword, and since all arguments to
      * __attribute__ are constant expressions, looking up global variables
      * would not make sense.  Therefore, 'var' is undefined.
+     *
      * See lex.c, function 'search', keyword 'in_gcc_attribute'.
      */
     /* expect+2: error: 'var' undefined [99] */
-    /* expect+1: syntax error '=' [249] */
+    /* expect+1: error: syntax error '=' [249] */
     var = 1,
     /* Syntactically ok, must be a constant expression though. */
     var > 0 ? 2 : 1)))
 my_printf(const char *, ...);
 void
 assignment_associativity(int arg)
+{
 	int left, right;
 	/*
 	 * Assignments are right-associative.  If they were left-associative,
 	 * the result of (left = right) would be an rvalue, resulting in this

--- src/tests/usr.bin/xlint/lint1/parse_type_name.c 2022/04/01 23:16:32	1.8
+++ src/tests/usr.bin/xlint/lint1/parse_type_name.c 2022/06/17 18:54:53	1.9

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse_type_name.c,v 1.8 2022/04/01 23:16:32 rillig Exp $	*/
+/*	$NetBSD: parse_type_name.c,v 1.9 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "parse_type_name.c"
 /*
  * Test parsing of the grammar rule 'type_name', which among others appears
  * in the expression 'sizeof(type_name)'.
  */
 void sink(unsigned long);
 void
 cover_type_name(void)
+{
 	/* cover 'abstract_declaration' */
 @@ -104,35 +104,35 @@ cover_abstract_decl_param_list(void)
 	 * All following __attribute__ come from direct_abstract_declarator.
 	 */
 	sink(sizeof(void (*)() __attribute__(()) __attribute__(())));
 	/* cover 'abstract_decl_lparen vararg_parameter_type_list T_RPAREN type_attribute_opt' */
 	sink(sizeof(void (*)(void) __attribute__(())));
 	/*
 	 * XXX: The grammar allows only a single type_attribute_opt.
 	 * All following __attribute__ come from direct_abstract_declarator.
 	 */
 	sink(sizeof(void (*)(void) __attribute__(()) __attribute__(())));
 	/* cover 'abstract_decl_lparen error T_RPAREN type_attribute_opt' */
-	/* expect+1: syntax error 'goto' [249] */
+	/* expect+1: error: syntax error 'goto' [249] */
 	sink(sizeof(void (*)(goto)));
-	/* expect+1: syntax error 'goto' [249] */
+	/* expect+1: error: syntax error 'goto' [249] */
 	sink(sizeof(void (*)(goto) __attribute__(())));
 	/*
 	 * XXX: The grammar allows only a single type_attribute_opt.
 	 * All following __attribute__ come from direct_abstract_declarator.
 	 */
-	/* expect+1: syntax error 'goto' [249] */
+	/* expect+1: error: syntax error 'goto' [249] */
 	sink(sizeof(void (*)(goto) __attribute__(()) __attribute__(())));
+}
 void
 cover_vararg_parameter_type_list(void)
+{
 	/* cover 'parameter_type_list' */
 	sink(sizeof(void (*)(double)));
 	/* cover 'parameter_type_list T_COMMA T_ELLIPSIS' */
 	sink(sizeof(void (*)(double, ...)));
 	/* cover 'T_ELLIPSIS' */

--- src/tests/usr.bin/xlint/lint1/feat_stacktrace.c 2022/01/15 14:22:03	1.2
+++ src/tests/usr.bin/xlint/lint1/feat_stacktrace.c 2022/06/17 18:54:53	1.3

 @@ -1,32 +1,32 @@
-/*	$NetBSD: feat_stacktrace.c,v 1.2 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: feat_stacktrace.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "feat_stacktrace.c"
 /*
  * In macros or nested includes, lint prints a stack trace to show exactly
  * where the code comes from.
  */
 # 1 "/usr/include/stdlib.h" 1 3 4
 # 38 "/usr/include/stdlib.h" 3 4
 # 39 "/usr/include/stdlib.h" 3 4
 # 1 "/usr/include/sys/types.h" 1 3 4
 # 43 "/usr/include/sys/types.h" 3 4
 # 1 "/usr/include/amd64/types.h" 1 3 4
 # 40 "/usr/include/amd64/types.h" 3 4
 # 1 "/usr/include/sys/featuretest.h" 1 3 4
 # 41 "/usr/include/amd64/types.h" 2 3 4
 # 1 "/usr/include/amd64/int_types.h" 1 3 4
 /*
  * The next filename is a relative filename since the tests are run without
  * the lint option -F, which would generate the fully qualified filename for
  * the main file as well.
  */
 # 1 "common_int_types.h" 1 3 4
-/* expect+1: typedef declares no type name [72] */
+/* expect+1: warning: typedef declares no type name [72] */
 typedef int;
 # 39 "common_int_types.h" 3 4
 # 39 "/usr/include/amd64/int_types.h" 2 3 4
 # 42 "/usr/include/amd64/types.h" 2 3 4
 # 68 "/usr/include/amd64/types.h" 3 4
 # 46 "/usr/include/sys/types.h" 2 3 4

--- src/tests/usr.bin/xlint/lint1/gcc_attribute_aligned.c 2022/01/15 14:22:03	1.2
+++ src/tests/usr.bin/xlint/lint1/gcc_attribute_aligned.c 2022/06/17 18:54:53	1.3

 @@ -1,14 +1,14 @@
-/*	$NetBSD: gcc_attribute_aligned.c,v 1.2 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: gcc_attribute_aligned.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_attribute_aligned.c"
 /*
  * Test size computations on aligned and packed structs.
  */
 typedef unsigned short uint16_t;
 typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 /* from sys/arch/x86/include/cpu_extended_state.h */
 union fp_addr {
 @@ -30,16 +30,16 @@ struct save87 {
 	uint16_t s87_sw __attribute__((aligned(4)));
 	uint16_t s87_tw __attribute__((aligned(4)));
 	union fp_addr s87_ip;
 	union fp_addr s87_dp;
 	struct fpacc87 s87_ac[8];
 };
 struct {
 	unsigned int sizeof_fp_addr: sizeof(union fp_addr) == 8 ? 1 : -1;
 	unsigned int sizeof_fpacc87: sizeof(struct fpacc87) == 10 ? 1 : -1;
 	/* FIXME: @4 2 + @4 2 + @4 2 + @4 8 + @4 8 + @2 (8 * 10) == 108 */
-	/* expect+1: illegal bit-field size: 255 */
+	/* expect+1: error: illegal bit-field size: 255 [36] */
 	unsigned int sizeof_save87: sizeof(struct save87) == 108 ? 1 : -1;
 };

--- src/tests/usr.bin/xlint/lint1/gcc_typeof_after_statement.c 2021/05/03 05:24:44	1.2
+++ src/tests/usr.bin/xlint/lint1/gcc_typeof_after_statement.c 2022/06/17 18:54:53	1.3

 @@ -1,22 +1,22 @@
-/*	$NetBSD: gcc_typeof_after_statement.c,v 1.2 2021/05/03 05:24:44 rillig Exp $	*/
+/*	$NetBSD: gcc_typeof_after_statement.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_typeof_after_statement.c"
 /*
  * Before cgram.y 1.226 from 2021-05-03, lint could not parse typeof(...) if
  * there was a statement before it.
  */
 void *
 example(void **ptr)
+{
 	return ({
 		if (*ptr != (void *)0)
 			ptr++;
 		__typeof__(*ptr) ret = *ptr;
 		ret;
 	});
+}
 /* Just to keep the .exp file. */
-/* expect+1: static function unused declared but not defined */
+/* expect+1: warning: static function unused declared but not defined [290] */
 static void unused(void);

--- src/tests/usr.bin/xlint/lint1/lex_wide_char.c 2021/06/20 18:38:12	1.2
+++ src/tests/usr.bin/xlint/lint1/lex_wide_char.c 2022/06/17 18:54:53	1.3

 @@ -1,41 +1,41 @@
-/*	$NetBSD: lex_wide_char.c,v 1.2 2021/06/20 18:38:12 rillig Exp $	*/
+/*	$NetBSD: lex_wide_char.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_wide_char.c"
 /*
  * Tests for lexical analysis of character constants.
+ *
  * C99 6.4.4.4 "Character constants"
  */
 void sink(int);
 void
 test(void)
+{
-	/* expect+1: empty character constant */
+	/* expect+1: error: empty character constant [73] */
 	sink(L'');
 	sink(L'a');
 	sink(L'\0');
 	/* UTF-8 */
-	/* expect+1: too many characters in character constant */
+	/* expect+1: error: too many characters in character constant [71] */
 	sink(L'ä');
 	/* GCC extension */
-	/* expect+1: dubious escape \e */
+	/* expect+1: warning: dubious escape \e [79] */
 	sink(L'\e');
 	/* since C99 */
 	sink(L'\x12');
 	/* octal */
 	sink(L'\177');
 	/* newline */
 	sink(L'\n');
-	/* expect+1: empty character constant */
+	/* expect+1: error: empty character constant [73] */
 	sink(L'');
+}

--- src/tests/usr.bin/xlint/lint1/lex_wide_string.c 2021/08/23 17:47:34	1.2
+++ src/tests/usr.bin/xlint/lint1/lex_wide_string.c 2022/06/17 18:54:53	1.3

 @@ -1,33 +1,33 @@
-/*	$NetBSD: lex_wide_string.c,v 1.2 2021/08/23 17:47:34 rillig Exp $	*/
+/*	$NetBSD: lex_wide_string.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_wide_string.c"
 /*
  * Test lexical analysis of wide string constants.
+ *
  * C99 6.4.5 "String literals"
  */
 void sink(const int *);
 void
 test(void)
+{
 	sink(L"");
 	sink(L"hello, world\n");
 	sink(L"\0");
 	sink(L"\0\0\0\0");
-	/* expect+1: no hex digits follow \x [74] */
+	/* expect+1: error: no hex digits follow \x [74] */
 	sink(L"\x");
-	/* expect+1: dubious escape \y [79] */
+	/* expect+1: warning: dubious escape \y [79] */
 	sink(L"\y");
 	sink(L"first" L"second");
 	/* expect+1: error: cannot concatenate wide and regular string literals [292] */
 	sink(L"wide" "plain");
+}

--- src/tests/usr.bin/xlint/lint1/msg_345.c 2021/06/27 20:47:13	1.2
+++ src/tests/usr.bin/xlint/lint1/msg_345.c 2022/06/17 18:54:53	1.3

 @@ -1,14 +1,14 @@
-/*	$NetBSD: msg_345.c,v 1.2 2021/06/27 20:47:13 rillig Exp $	*/
+/*	$NetBSD: msg_345.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_345.c"
 // Test for message: generic selection requires C11 or later [345]
 /* Omit flag -g since it silences c11ism. */
 /* lint1-flags: -Sw */
 int
 test(int x)
+{
-	/* expect+1: generic selection requires C11 or later [345] */
+	/* expect+1: error: generic selection requires C11 or later [345] */
 	return _Generic(x, default: 3) + x;
+}

--- src/tests/usr.bin/xlint/lint1/op_colon.c 2022/01/15 14:22:03	1.2
+++ src/tests/usr.bin/xlint/lint1/op_colon.c 2022/06/17 18:54:53	1.3

 @@ -1,50 +1,50 @@
-/*	$NetBSD: op_colon.c,v 1.2 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: op_colon.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "op_colon.c"
 /*
  * Test handling of the operator ':', as part of the '?:'.
  */
 /* lint1-extra-flags: -p */
 void sink(void *);
 void
 test_merge_qualifiers(_Bool cond, int *p, const int *c, volatile int *v,
 		      const volatile int *cv)
+{
 	sink(cond ? p : p);
-	/* expect+1: 'pointer to const int' */
+	/* expect+1: ... 'pointer to const int' ... */
 	sink(cond ? p : c);
-	/* expect+1: 'pointer to volatile int' */
+	/* expect+1: ... 'pointer to volatile int' ... */
 	sink(cond ? p : v);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? p : cv);
-	/* expect+1: 'pointer to const int' */
+	/* expect+1: ... 'pointer to const int' ... */
 	sink(cond ? c : p);
-	/* expect+1: 'pointer to const int' */
+	/* expect+1: ... 'pointer to const int' ... */
 	sink(cond ? c : c);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? c : v);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? c : cv);
-	/* expect+1: 'pointer to volatile int' */
+	/* expect+1: ... 'pointer to volatile int' ... */
 	sink(cond ? v : p);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? v : c);
-	/* expect+1: 'pointer to volatile int' */
+	/* expect+1: ... 'pointer to volatile int' ... */
 	sink(cond ? v : v);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? v : cv);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? cv : p);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? cv : c);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? cv : v);
-	/* expect+1: 'pointer to const volatile int' */
+	/* expect+1: ... 'pointer to const volatile int' ... */
 	sink(cond ? cv : cv);
+}

--- src/tests/usr.bin/xlint/lint1/stmt_for.c 2022/01/15 14:22:03	1.2
+++ src/tests/usr.bin/xlint/lint1/stmt_for.c 2022/06/17 18:54:53	1.3

 @@ -1,17 +1,17 @@
-/*	$NetBSD: stmt_for.c,v 1.2 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: stmt_for.c,v 1.3 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "stmt_for.c"
 /*
  * Before func.c 1.111 from 2021-06-19, lint ran into an assertion failure:
+ *
  * "dcs->d_next == NULL" failed in funcend at func.c:422
  */
 void
 test(void)
+{
 	/* expect+1: error: syntax error '0' [249] */
 	for (0 0;
+}
-/* expect+1: cannot recover from previous errors */
+/* expect+1: error: cannot recover from previous errors [224] */

--- src/tests/usr.bin/xlint/lint1/gcc_attribute_enum.c 2021/07/25 18:48:47	1.4
+++ src/tests/usr.bin/xlint/lint1/gcc_attribute_enum.c 2022/06/17 18:54:53	1.5

 @@ -1,14 +1,14 @@
-/*	$NetBSD: gcc_attribute_enum.c,v 1.4 2021/07/25 18:48:47 rillig Exp $	*/
+/*	$NetBSD: gcc_attribute_enum.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_attribute_enum.c"
 /*
  * Tests for the GCC __attribute__ for enumerators.
+ *
  * https://gcc.gnu.org/onlinedocs/gcc/Enumerator-Attributes.html
  */
 /*
  * Attributes in enum-specifier.
+ *
  * See GCC, c-parser.c, function c_parser_enum_specifier.
  */
 @@ -27,20 +27,20 @@ enum __attribute__(()) {
  * Attributes in enumerator.
+ *
  * See GCC, c-parser.c, function c_parser_enum_specifier.
  */
 enum without_initializer {
 	NO_INIT_FIRST __attribute__(()),
 	NO_INIT_LAST __attribute__(())
 };
 enum with_initializer {
 	INIT_FIRST __attribute__(()) = 1,
 	INIT_LAST __attribute__(()) = 2,
-	/* expect+1: syntax error '__attribute__' [249] */
+	/* expect+1: error: syntax error '__attribute__' [249] */
 	INIT_WRONG = 3 __attribute__(()),
 };
 enum tag {
 	TAG
 };

--- src/tests/usr.bin/xlint/lint1/lex_string.c 2021/11/20 17:27:46	1.4
+++ src/tests/usr.bin/xlint/lint1/lex_string.c 2022/06/17 18:54:53	1.5

 @@ -1,36 +1,36 @@
-/*	$NetBSD: lex_string.c,v 1.4 2021/11/20 17:27:46 rillig Exp $	*/
+/*	$NetBSD: lex_string.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_string.c"
 /*
  * Test lexical analysis of string constants.
+ *
  * C99 6.4.5 "String literals"
  */
 void sink(const char *);
 void
 test(void)
+{
 	sink("");
 	sink("hello, world\n");
 	sink("\0");
 	sink("\0\0\0\0");
-	/* expect+1: no hex digits follow \x [74] */
+	/* expect+1: error: no hex digits follow \x [74] */
 	sink("\x");		/* unfinished */
-	/* expect+1: dubious escape \y [79] */
+	/* expect+1: warning: dubious escape \y [79] */
 	sink("\y");		/* unknown escape sequence */
 	sink("first" "second");
 	/* expect+1: error: cannot concatenate wide and regular string literals [292] */
 	sink("plain" L"wide");
+}
 /* TODO: test digraphs inside string literals */
 /* TODO: test trigraphs inside string literals */

--- src/tests/usr.bin/xlint/lint1/msg_005.c 2021/09/04 13:45:37	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_005.c 2022/06/17 18:54:53	1.5

 @@ -1,29 +1,29 @@
-/*	$NetBSD: msg_005.c,v 1.4 2021/09/04 13:45:37 rillig Exp $	*/
+/*	$NetBSD: msg_005.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_005.c"
 // Test for message: modifying typedef with '%s'; only qualifiers allowed [5]
 typedef int number;
 /* expect+1: warning: modifying typedef with 'signed'; only qualifiers allowed [5] */
 typedef number signed signed_number;
 /* expect+1: warning: modifying typedef with 'unsigned'; only qualifiers allowed [5] */
 typedef number unsigned unsigned_number;
 /* expect+1: warning: modifying typedef with 'short'; only qualifiers allowed [5] */
 typedef number short short_number;
-/* expect+1: modifying typedef with 'long'; only qualifiers allowed [5] */
+/* expect+1: warning: modifying typedef with 'long'; only qualifiers allowed [5] */
 typedef number long long_number;
 /*
  * If the type qualifier comes first, the following name is interpreted as a
  * new name, not as the one referring to the typedef.  This makes the above
  * type modifications even more obscure.
  */
 /* expect+1: error: syntax error 'prefix_long_number' [249] */
 typedef long number prefix_long_number;
 /* Type qualifiers are OK. */
 typedef number const const_number;

--- src/tests/usr.bin/xlint/lint1/msg_041.c 2022/02/07 02:44:49	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_041.c 2022/06/17 18:54:53	1.5

 @@ -1,10 +1,10 @@
-/*	$NetBSD: msg_041.c,v 1.4 2022/02/07 02:44:49 rillig Exp $	*/
+/*	$NetBSD: msg_041.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_041.c"
 // Test for message: bit-field in union is very unusual [41]
 union u {
 	int member;
-	/* expect+1: bit-field in union is very unusual [41] */
+	/* expect+1: warning: bit-field in union is very unusual [41] */
 	unsigned bit_field : 7;
 };

--- src/tests/usr.bin/xlint/lint1/msg_048.c 2022/04/08 21:48:19	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_048.c 2022/06/17 18:54:53	1.5

 @@ -1,22 +1,22 @@
-/*	$NetBSD: msg_048.c,v 1.4 2022/04/08 21:48:19 rillig Exp $	*/
+/*	$NetBSD: msg_048.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_048.c"
 // Test for message: overflow in enumeration values: %s [48]
 /*
  * Before decl.c 1.269 from 2022-04-08, the comparison for enum constant
  * overflow was done in signed arithmetic, and since 'enumval' wrapped
  * around, its value became INT_MIN, at least on platforms where integer
  * overflow was defined as 2-complements wrap-around.  When comparing
  * 'enumval - 1 == TARG_INT_MAX', there was another integer overflow, and
  * this one was optimized away by GCC, taking advantage of the undefined
  * behavior.
  */
 enum int_limits {
 	MAX_MINUS_2 = 0x7ffffffd,
 	MAX_MINUS_1,
 	MAX,
-	/* expect+1: overflow in enumeration values: MIN [48] */
+	/* expect+1: warning: overflow in enumeration values: MIN [48] */
 	MIN,
 	MIN_PLUS_1
 };

--- src/tests/usr.bin/xlint/lint1/msg_080.c 2021/07/04 13:44:43	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_080.c 2022/06/17 18:54:53	1.5

 @@ -1,7 +1,7 @@
-/*	$NetBSD: msg_080.c,v 1.4 2021/07/04 13:44:43 rillig Exp $	*/
+/*	$NetBSD: msg_080.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_080.c"
 // Test for message: dubious escape \%o [80]
-/* expect+1: dubious escape \177 [80] */
+/* expect+1: warning: dubious escape \177 [80] */
 char backslash_delete = '\';

--- src/tests/usr.bin/xlint/lint1/msg_184.c 2021/08/14 13:00:55	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_184.c 2022/06/17 18:54:53	1.5

 @@ -1,11 +1,11 @@
-/*	$NetBSD: msg_184.c,v 1.4 2021/08/14 13:00:55 rillig Exp $	*/
+/*	$NetBSD: msg_184.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_184.c"
 // Test for message: illegal combination of '%s' and '%s' [184]
 int *
 example(char *cp)
+{
-	/* expect+1: illegal combination of 'pointer to int' and 'pointer to char' [184] */
+	/* expect+1: warning: illegal combination of 'pointer to int' and 'pointer to char' [184] */
 	return cp;
+}

--- src/tests/usr.bin/xlint/lint1/msg_250.c 2022/04/24 20:08:23	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_250.c 2022/06/17 18:54:53	1.5

 @@ -1,10 +1,10 @@
-/*	$NetBSD: msg_250.c,v 1.4 2022/04/24 20:08:23 rillig Exp $	*/
+/*	$NetBSD: msg_250.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_250.c"
 // Test for message: unknown character \%o [250]
-/* expect+1: unknown character \100 [250] */
+/* expect+1: error: unknown character \100 [250] */
 @deprecated
 /* expect+2: error: old style declaration; add 'int' [1] */
-/* expect+1: syntax error 'char' [249] */
+/* expect+1: error: syntax error 'char' [249] */
 char *gets(void);

--- src/tests/usr.bin/xlint/lint1/msg_265.c 2021/12/22 14:25:35	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_265.c 2022/06/17 18:54:53	1.5

 @@ -1,16 +1,16 @@
-/*	$NetBSD: msg_265.c,v 1.4 2021/12/22 14:25:35 rillig Exp $	*/
+/*	$NetBSD: msg_265.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_265.c"
 /* Test for message: %s does not support 'long long' [265] */
 /* lint1-flags: -w */
-/* expect+1: C90 does not support 'long long' [265] */
+/* expect+1: warning: C90 does not support 'long long' [265] */
 long long unsupported_variable;
 /*LONGLONG*/
 long long suppressed_variable,
     second_suppressed_variable;
-/* expect+1: C90 does not support 'long long' [265] */
+/* expect+1: warning: C90 does not support 'long long' [265] */
 long long another_unsupported_variable;

--- src/tests/usr.bin/xlint/lint1/msg_333.c 2021/07/04 07:09:39	1.4
+++ src/tests/usr.bin/xlint/lint1/msg_333.c 2022/06/17 18:54:53	1.5

 @@ -1,39 +1,39 @@
-/*	$NetBSD: msg_333.c,v 1.4 2021/07/04 07:09:39 rillig Exp $	*/
+/*	$NetBSD: msg_333.c,v 1.5 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_333.c"
 // Test for message: controlling expression must be bool, not '%s' [333]
 //
 // See d_c99_bool_strict.c for many more examples.
 /* lint1-extra-flags: -T */
 typedef _Bool bool;
 const char *
 example(bool b, int i, const char *p)
+{
 	if (b)
 		return "bool";
-	/* expect+1: must be bool, not 'int' [333] */
+	/* expect+1: error: controlling expression must be bool, not 'int' [333] */
 	if (i)
 		return "int";
-	/* expect+1: must be bool, not 'pointer' [333] */
+	/* expect+1: error: controlling expression must be bool, not 'pointer' [333] */
 	if (p)
 		return "pointer";
 	if (__lint_false) {
 		/* expect+1: warning: statement not reached [193] */
 		return "bool constant";
+	}
-	/* expect+1: controlling expression must be bool, not 'int' [333] */
+	/* expect+1: error: controlling expression must be bool, not 'int' [333] */
 	if (0) {
 		/* expect+1: warning: statement not reached [193] */
 		return "integer constant";
+	}
 	return p + i;
+}

--- src/tests/usr.bin/xlint/lint1/gcc_stmt_asm.c 2021/07/21 21:04:00	1.3
+++ src/tests/usr.bin/xlint/lint1/gcc_stmt_asm.c 2022/06/17 18:54:53	1.4

 @@ -1,14 +1,14 @@
-/*	$NetBSD: gcc_stmt_asm.c,v 1.3 2021/07/21 21:04:00 rillig Exp $	*/
+/*	$NetBSD: gcc_stmt_asm.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "gcc_stmt_asm.c"
 /*
  * Tests for the GCC 'asm' statement.
  */
 void
 function(void)
+{
 	/*
 	 * lint is not really interested in assembly language, therefore it
 	 * just skips everything until and including the closing parenthesis.
 	 */
 @@ -23,20 +23,20 @@ function(void)
 	__asm__();
+}
 /*
  * Even on the top level, 'asm' is allowed.  It is interpreted as a
  * declaration.
  */
 __asm__();
 void
 syntax_error(void)
+{
-	/* expect+1: syntax error '__asm__' [249] */
+	/* expect+1: error: syntax error '__asm__' [249] */
 	int i = __asm__();
+}
 __asm__(
 /* cover read_until_rparen at EOF */
 /* expect+1: error: syntax error '' [249] */

--- src/tests/usr.bin/xlint/lint1/init_c90.c 2022/02/27 11:40:30	1.3
+++ src/tests/usr.bin/xlint/lint1/init_c90.c 2022/06/17 18:54:53	1.4

 @@ -1,30 +1,30 @@
-/*	$NetBSD: init_c90.c,v 1.3 2022/02/27 11:40:30 rillig Exp $	*/
+/*	$NetBSD: init_c90.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "init_c90.c"
 /*
  * Test initialization before C99.
+ *
  * C90 3.5.7
  */
 /* lint1-flags: -sw */
 struct point {
 	int x, y;
 };
 struct point point_c90 = { 0, 0 };
 /* expect+2: warning: struct or union member name in initializer is a C99 feature [313] */
 /* expect+1: warning: struct or union member name in initializer is a C99 feature [313] */
 struct point point_c99 = { .x = 0, .y = 0 };
 struct point points_c90[] = {{ 0, 0 }};
 /* expect+1: warning: array initializer with designators is a C99 feature [321] */
 struct point points_c99[] = {[3] = { 0, 0 }};
 struct point
 compound_literal(void) {
-	/* expect+1: compound literals are a C99/GCC extension [319] */
+	/* expect+1: error: compound literals are a C99/GCC extension [319] */
 	return (struct point){ 0, 0 };
+}

--- src/tests/usr.bin/xlint/lint1/lex_integer_ilp32.c 2021/08/21 11:50:57	1.3
+++ src/tests/usr.bin/xlint/lint1/lex_integer_ilp32.c 2022/06/17 18:54:53	1.4

 @@ -1,44 +1,44 @@
-/*	$NetBSD: lex_integer_ilp32.c,v 1.3 2021/08/21 11:50:57 rillig Exp $	*/
+/*	$NetBSD: lex_integer_ilp32.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_integer_ilp32.c"
 /*
  * Tests for lexical analysis of integer constants.
+ *
  * C99 6.4.4.1 "Integer constants"
  */
 /* lint1-only-if: ilp32 */
 void sinki(int);
 void sinku(unsigned int);
 /* All platforms supported by lint have 32-bit int in two's complement. */
 void
 test_signed_int(void)
+{
 	sinki(0);
 	sinki(-1);
 	sinki(2147483647);
-	/* expect+1: 'unsigned long' to 'int' is out of range, arg #1 [295] */
+	/* expect+1: warning: conversion of 'unsigned long' to 'int' is out of range, arg #1 [295] */
 	sinki(2147483648);
 	sinki(-2147483647);
-	/* expect+2: ANSI C treats constant as unsigned, op - [218] */
+	/* expect+2: warning: ANSI C treats constant as unsigned, op - [218] */
-	/* expect+1: 'unsigned long' to 'int' is out of range, arg #1 [295] */
+	/* expect+1: warning: conversion of 'unsigned long' to 'int' is out of range, arg #1 [295] */
 	sinki(-2147483648);
+}
 void
 test_unsigned_int(void)
+{
 	sinku(0);
 	sinku(4294967295U);
-	/* expect+1: integer constant out of range [252] */
+	/* expect+1: warning: integer constant out of range [252] */
 	sinku(4294967296U);
+}

--- src/tests/usr.bin/xlint/lint1/msg_069.c 2022/04/08 21:29:29	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_069.c 2022/06/17 18:54:53	1.4

 @@ -1,12 +1,12 @@
-/*	$NetBSD: msg_069.c,v 1.3 2022/04/08 21:29:29 rillig Exp $	*/
+/*	$NetBSD: msg_069.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_069.c"
 // Test for message: inappropriate qualifiers with 'void' [69]
 /* expect+2: error: void type for 'const_void' [19] */
-/* expect+1: warning: inappropriate qualifiers with 'void' */
+/* expect+1: warning: inappropriate qualifiers with 'void' [69] */
 const void const_void;
 /* expect+2: error: void type for 'volatile_void' [19] */
-/* expect+1: warning: inappropriate qualifiers with 'void' */
+/* expect+1: warning: inappropriate qualifiers with 'void' [69] */
 volatile void volatile_void;

--- src/tests/usr.bin/xlint/lint1/msg_103.c 2021/07/04 17:01:58	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_103.c 2022/06/17 18:54:53	1.4

 @@ -1,16 +1,16 @@
-/*	$NetBSD: msg_103.c,v 1.3 2021/07/04 17:01:58 rillig Exp $	*/
+/*	$NetBSD: msg_103.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_103.c"
 // Test for message: left operand of '.' must be struct or union, not '%s' [103]
 struct point {
 	int x, y;
 };
 void
 test(struct point pt, struct point *ptr)
+{
 	pt.x = 0;
-	/* expect+1: left operand of '.' must be struct or union, not 'pointer to struct point' [103] */
+	/* expect+1: error: left operand of '.' must be struct or union, not 'pointer to struct point' [103] */
 	ptr.y = 0;
+}

--- src/tests/usr.bin/xlint/lint1/msg_104.c 2021/07/04 17:01:58	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_104.c 2022/06/17 18:54:53	1.4

 @@ -1,17 +1,17 @@
-/*	$NetBSD: msg_104.c,v 1.3 2021/07/04 17:01:58 rillig Exp $	*/
+/*	$NetBSD: msg_104.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_104.c"
 // Test for message: left operand of '->' must be pointer to struct or union, not '%s' [104]
 struct point {
 	int x, y;
 };
 /* ARGSUSED */
 void
 test(struct point pt, struct point *ptr)
+{
-	/* expect+1: left operand of '->' must be pointer to struct or union, not 'struct point' [104] */
+	/* expect+1: error: left operand of '->' must be pointer to struct or union, not 'struct point' [104] */
 	pt->x = 0;
 	ptr->y = 0;
+}

--- src/tests/usr.bin/xlint/lint1/msg_211.c 2021/08/16 18:51:58	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_211.c 2022/06/17 18:54:53	1.4

 @@ -1,22 +1,22 @@
-/*	$NetBSD: msg_211.c,v 1.3 2021/08/16 18:51:58 rillig Exp $	*/
+/*	$NetBSD: msg_211.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_211.c"
 // Test for message: return value type mismatch (%s) and (%s) [211]
 struct str {
 	int member;
 };
 int
 return_int(double dbl, void *ptr, struct str str)
+{
 	if (dbl > 0.0)
 		return dbl;
 	if (ptr != (void *)0)
 		/* expect+1: warning: illegal combination of integer (int) and pointer (pointer to void) [183] */
 		return ptr;
 	if (str.member > 0)
-		/* expect+1: error: return value type mismatch (int) and (struct str) [211 */
+		/* expect+1: error: return value type mismatch (int) and (struct str) [211] */
 		return str;
 	return 3;
+}

--- src/tests/usr.bin/xlint/lint1/msg_251.c 2021/06/29 07:17:43	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_251.c 2022/06/17 18:54:53	1.4

 @@ -1,10 +1,10 @@
-/*	$NetBSD: msg_251.c,v 1.3 2021/06/29 07:17:43 rillig Exp $	*/
+/*	$NetBSD: msg_251.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_251.c"
 // Test for message: malformed integer constant [251]
-/* expect+1: malformed integer constant */
+/* expect+1: warning: malformed integer constant [251] */
 int lll = 123LLL;
-/* expect+1: malformed integer constant */
+/* expect+1: warning: malformed integer constant [251] */
 unsigned int uu = 123UU;

--- src/tests/usr.bin/xlint/lint1/msg_253.c 2021/06/29 07:17:43	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_253.c 2022/06/17 18:54:53	1.4

 @@ -1,8 +1,8 @@
-/*	$NetBSD: msg_253.c,v 1.3 2021/06/29 07:17:43 rillig Exp $	*/
+/*	$NetBSD: msg_253.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_253.c"
 // Test for message: unterminated character constant [253]
-/* expect+3: [253] */
+/* expect+3: error: unterminated character constant [253] */
-/* expect+2: syntax error '' */
+/* expect+2: error: syntax error '' [249] */
+'

--- src/tests/usr.bin/xlint/lint1/msg_254.c 2021/06/29 07:17:43	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_254.c 2022/06/17 18:54:53	1.4

 @@ -1,19 +1,19 @@
-/*	$NetBSD: msg_254.c,v 1.3 2021/06/29 07:17:43 rillig Exp $	*/
+/*	$NetBSD: msg_254.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_254.c"
 /* Test for message: newline in string or char constant [254] */
 /* lint1-flags: -tw */
 /*
  * The sequence backslash-newline is a GCC extension.
  * C99 does not allow it.
  */
-/* expect+6: newline in string or char constant [254] */
+/* expect+6: error: newline in string or char constant [254] */
-/* expect+5: unterminated string constant [258] */
+/* expect+5: error: unterminated string constant [258] */
-/* expect+4: syntax error '"' [249] */
+/* expect+4: error: syntax error '"' [249] */
-/* expect+4: newline in string or char constant [254] */
+/* expect+4: error: newline in string or char constant [254] */
-/* expect+3: unterminated string constant [258] */
+/* expect+3: error: unterminated string constant [258] */
 "line1
 line2"

--- src/tests/usr.bin/xlint/lint1/msg_257.c 2021/08/27 20:49:25	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_257.c 2022/06/17 18:54:53	1.4

 @@ -1,28 +1,28 @@
-/*	$NetBSD: msg_257.c,v 1.3 2021/08/27 20:49:25 rillig Exp $	*/
+/*	$NetBSD: msg_257.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_257.c"
 // Test for message: extra characters in lint comment [257]
 void take(const void *);
 /* expect+1: warning: extra characters in lint comment [257] */
 /* FALLTHROUGH 3 */
 /* expect+1: warning: extra characters in lint comment [257] */
 /* FALLTHROUGH extra */
 /* PRINTFLIKE 7 */
 void
 my_printf(const char *fmt)
-/* expect+1: warning: argument number mismatch with directive: */
+/* expect+1: warning: argument number mismatch with directive: ** PRINTFLIKE ** [283] */
+{
 	take(fmt);
+}
 /* expect+1: warning: extra characters in lint comment [257] */
 /* SCANFLIKE extra */
 void
 my_scanf(const char *fmt)
+{
 	take(fmt);
+}

--- src/tests/usr.bin/xlint/lint1/msg_259_c90.c 2021/09/02 17:55:27	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_259_c90.c 2022/06/17 18:54:53	1.4

 @@ -1,14 +1,14 @@
-/*	$NetBSD: msg_259_c90.c,v 1.3 2021/09/02 17:55:27 rillig Exp $	*/
+/*	$NetBSD: msg_259_c90.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_259_c90.c"
 /* Test for message: argument #%d is converted from '%s' to '%s' due to prototype [259] */
 /*
  * This warning detects function calls that are translated in very different
  * translation environments, one where prototypes are omitted, and one where
  * prototypes are active.  It is possible to make such code interoperable,
  * but that requires that each argument is converted to its proper type by
  * the caller of the function.
+ *
  * When lint is run with the '-s' flag, it no longer warns about code with
  * incompatibilities between traditional C and C90, therefore this test omits
 @@ -37,27 +37,27 @@ void
 change_in_type_width(char c, int i, long l)
+{
 	plain_char(c);
 	signed_int(c);
 	/* No warning 259 on LP64, only on ILP32 */
 	signed_long(c);
 	plain_char(i);		/* XXX: why no warning? */
 	signed_int(i);
 	/* No warning 259 on LP64, only on ILP32 */
 	signed_long(i);
 	plain_char(l);		/* XXX: why no warning? */
-	/* expect+1: from 'long' to 'int' due to prototype [259] */
+	/* expect+1: ... from 'long' to 'int' due to prototype [259] */
 	signed_int(l);
 	signed_long(l);
+}
 /*
  * Converting a signed integer type to its corresponding unsigned integer
  * type (C99 6.2.5p6) is usually not a problem since the actual values of the
  * expressions are usually not anywhere near the maximum signed value.  From
  * a technical standpoint, it is correct to warn here since even small
  * negative numbers may result in very large positive numbers.
+ *
  * A common case where it occurs is when the difference of two pointers is
  * converted to size_t.  The type ptrdiff_t is defined to be signed, but in

--- src/tests/usr.bin/xlint/lint1/msg_283.c 2021/08/30 19:48:21	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_283.c 2022/06/17 18:54:53	1.4

	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: msg_283.c,v 1.3 2021/08/30 19:48:21 rillig Exp $ */	1	/* $NetBSD: msg_283.c,v 1.4 2022/06/17 18:54:53 rillig Exp $ */
2	# 3 "msg_283.c"	2	# 3 "msg_283.c"
3		3
4	// Test for message: argument number mismatch with directive: /* %s */ [283]	4	// Test for message: argument number mismatch with directive: /* %s */ [283]
5		5
6	/* Do not warn about unused parameters. */	6	/* Do not warn about unused parameters. */
7	/* lint1-extra-flags: -X 231 */	7	/* lint1-extra-flags: -X 231 */
8		8
9	/* PRINTFLIKE */	9	/* PRINTFLIKE */
10	void	10	void
11	printflike_comment(const char *fmt)	11	printflike_comment(const char *fmt)
12	{	12	{
13	}	13	}
14		14
	@@ -17,16 +17,16 @@ void		@@ -17,16 +17,16 @@ void
17	printflike_0_comment(const char *fmt)	17	printflike_0_comment(const char *fmt)
18	{	18	{
19	}	19	}
20		20
21	/* PRINTFLIKE 2 */	21	/* PRINTFLIKE 2 */
22	void	22	void
23	printflike_2_comment(int a, const char *fmt)	23	printflike_2_comment(int a, const char *fmt)
24	{	24	{
25	}	25	}
26		26
27	/* PRINTFLIKE 3 */	27	/* PRINTFLIKE 3 */
28	void	28	void
29	printflike_3_comment(int a, const char *fmt)	29	printflike_3_comment(int a, const char *fmt)
30	/* expect+1: warning: argument number mismatch with directive */	30	/* expect+1: warning: argument number mismatch with directive: PRINTFLIKE [283] */
31	{	31	{
32	}	32	}

--- src/tests/usr.bin/xlint/lint1/msg_289.c 2021/08/27 20:49:25	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_289.c 2022/06/17 18:54:53	1.4

 @@ -1,11 +1,11 @@
-/*	$NetBSD: msg_289.c,v 1.3 2021/08/27 20:49:25 rillig Exp $	*/
+/*	$NetBSD: msg_289.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_289.c"
 // Test for message: can't be used together: /* PRINTFLIKE */ /* SCANFLIKE */ [289]
 /* PRINTFLIKE */ /* SCANFLIKE */
 void
 both(void)
-/* expect+1: warning: can't be used together */
+/* expect+1: warning: can't be used together: ** PRINTFLIKE ** ** SCANFLIKE ** [289] */
+{
+}

--- src/tests/usr.bin/xlint/lint1/msg_312.c 2021/12/22 14:25:35	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_312.c 2022/06/17 18:54:53	1.4

 @@ -1,9 +1,9 @@
-/*	$NetBSD: msg_312.c,v 1.3 2021/12/22 14:25:35 rillig Exp $	*/
+/*	$NetBSD: msg_312.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_312.c"
 /* Test for message: %s does not support // comments [312] */
 /* lint1-flags: -tw */
-/* expect+1: traditional C does not support // comments [312] */
+/* expect+1: warning: traditional C does not support // comments [312] */
 // C99 comment

--- src/tests/usr.bin/xlint/lint1/msg_342.c 2021/07/25 22:43:08	1.3
+++ src/tests/usr.bin/xlint/lint1/msg_342.c 2022/06/17 18:54:53	1.4

 @@ -1,15 +1,15 @@
-/*	$NetBSD: msg_342.c,v 1.3 2021/07/25 22:43:08 rillig Exp $	*/
+/*	$NetBSD: msg_342.c,v 1.4 2022/06/17 18:54:53 rillig Exp $	*/
-# 3 "msg_341.c"
+# 3 "msg_342.c"
 // Test for message: argument to '%s' must be cast to 'unsigned char', not to '%s' [342]
 /*
  * Ensure that the functions from <ctype.h> are called with the correct
  * argument.
  */
 /* NetBSD 9.99.81, <ctype.h> */
 extern const unsigned short *_ctype_tab_;
 extern const short *_tolower_tab_;
 extern const short *_toupper_tab_;
 int isalnum(int);
 @@ -63,39 +63,39 @@ cover_is_ctype_function(char c)
 	tolower(c);
 	/* expect+1: warning: argument to 'toupper' must be 'unsigned char' or EOF, not 'char' [341] */
 	toupper(c);
 	/* Functions with similar names are not checked. */
 	is_other(c);
 	to_other(c);
+}
 void
 function_call_char(char c)
+{
-	/* expect+1: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' */
+	/* expect+1: warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341] */
 	(isspace)(c);
 	/* This is the only allowed form. */
 	isspace((unsigned char)c);
 	/* The cast to 'int' is redundant, it doesn't hurt though. */
 	isspace((int)(unsigned char)c);
-	/* expect+1: argument to 'isspace' must be cast to 'unsigned char', not to 'int' */
+	/* expect+1: warning: argument to 'isspace' must be cast to 'unsigned char', not to 'int' [342] */
 	isspace((int)c);
-	/* expect+1: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' */
+	/* expect+1: warning: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' [342] */
 	isspace((unsigned int)c);
+}
 /*
  * If the expression starts with type 'unsigned char', it can be cast to any
  * other type.  Chances are low enough that the cast is to 'char', which would
  * be the only bad type.
  */
 void
 function_call_unsigned_char(unsigned char c)
+{
 	(isspace)(c);
 @@ -106,25 +106,25 @@ function_call_unsigned_char(unsigned cha
 /* When used in a loop of fgetc, the type is already 'int'.  That's fine. */
 void
 function_call_int(int c)
+{
 	isspace(c);
+}
 void
 macro_invocation_NetBSD(char c)
+{
-	/* expect+1: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' [341] */
 	sink(((int)((_ctype_tab_ + 1)[(c)] & 0x0040)));
 	/* This is the only allowed form. */
 	sink(((int)((_ctype_tab_ + 1)[((unsigned char)c)] & 0x0040)));
-	/* expect+1: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' [342] */
 	sink(((int)((_ctype_tab_ + 1)[((int)c)] & 0x0040)));
-	/* expect+1: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' */
+	/* expect+1: warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' [342] */
 	sink(((int)((_ctype_tab_ + 1)[((unsigned int)c)] & 0x0040)));
+}

--- src/tests/usr.bin/xlint/lint1/Attic/msg_342.exp 2021/07/25 22:43:08	1.3
+++ src/tests/usr.bin/xlint/lint1/Attic/msg_342.exp 2022/06/17 18:54:53	1.4

 @@ -1,20 +1,20 @@
-msg_341.c(39): warning: argument to 'isalnum' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(39): warning: argument to 'isalnum' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(41): warning: argument to 'isalpha' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(41): warning: argument to 'isalpha' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(43): warning: argument to 'isblank' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(43): warning: argument to 'isblank' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(45): warning: argument to 'iscntrl' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(45): warning: argument to 'iscntrl' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(47): warning: argument to 'isdigit' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(47): warning: argument to 'isdigit' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(49): warning: argument to 'isgraph' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(49): warning: argument to 'isgraph' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(51): warning: argument to 'islower' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(51): warning: argument to 'islower' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(53): warning: argument to 'isprint' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(53): warning: argument to 'isprint' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(55): warning: argument to 'ispunct' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(55): warning: argument to 'ispunct' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(57): warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(57): warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(59): warning: argument to 'isupper' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(59): warning: argument to 'isupper' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(61): warning: argument to 'isxdigit' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(61): warning: argument to 'isxdigit' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(63): warning: argument to 'tolower' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(63): warning: argument to 'tolower' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(65): warning: argument to 'toupper' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(65): warning: argument to 'toupper' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(77): warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(77): warning: argument to 'isspace' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(86): warning: argument to 'isspace' must be cast to 'unsigned char', not to 'int' [342]
+msg_342.c(86): warning: argument to 'isspace' must be cast to 'unsigned char', not to 'int' [342]
-msg_341.c(89): warning: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' [342]
+msg_342.c(89): warning: argument to 'isspace' must be cast to 'unsigned char', not to 'unsigned int' [342]
-msg_341.c(120): warning: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' [341]
+msg_342.c(120): warning: argument to 'function from <ctype.h>' must be 'unsigned char' or EOF, not 'char' [341]
-msg_341.c(126): warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' [342]
+msg_342.c(126): warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'int' [342]
-msg_341.c(129): warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' [342]
+msg_342.c(129): warning: argument to 'function from <ctype.h>' must be cast to 'unsigned char', not to 'unsigned int' [342]

--- src/tests/usr.bin/xlint/lint1/lex_integer.c 2021/08/28 21:01:34	1.9
+++ src/tests/usr.bin/xlint/lint1/lex_integer.c 2022/06/17 18:54:53	1.10

 @@ -1,150 +1,150 @@
-/*	$NetBSD: lex_integer.c,v 1.9 2021/08/28 21:01:34 rillig Exp $	*/
+/*	$NetBSD: lex_integer.c,v 1.10 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "lex_integer.c"
 /*
  * Tests for lexical analysis of integer constants.
+ *
  * C99 6.4.4.1 "Integer constants"
  */
 /* lint1-only-if: lp64 */
 long signed_long;
 unsigned long long unsigned_long_long_var;
 struct s {
 	int member;
 };
 /*
  * When lint tries to convert the argument to 'struct s', it prints the
  * actual type of the argument as a side effect.
  */
 void print_type(struct s);
 void
 no_suffix(void)
+{
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(0);
 	/* The '-' is not part of the constant, it is a unary operator. */
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(-1);
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(2147483647);
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(0x7fffffff);
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(017777777777);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(0x80000000);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(020000000000);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(0xffffffff);
-	/* expect+1: passing 'long' */
+	/* expect+1: ... passing 'long' ... */
 	print_type(2147483648);
-	/* expect+1: passing 'long' */
+	/* expect+1: ... passing 'long' ... */
 	print_type(0x0000000100000000);
-	/* expect+1: passing 'long' */
+	/* expect+1: ... passing 'long' ... */
 	print_type(0x7fffffffffffffff);
-	/* expect+1: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(0x8000000000000000);
-	/* expect+1: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(0xffffffffffffffff);
 	/* expect+2: warning: integer constant out of range [252] */
-	/* expect+1: warning: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(0x00010000000000000000);
+}
 void
 suffix_u(void)
+{
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(3U);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(3u);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(4294967295U);
-	/* expect+1: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(4294967296U);
+}
 void
 suffix_l(void)
+{
-	/* expect+1: passing 'long' */
+	/* expect+1: ... passing 'long' ... */
 	print_type(3L);
-	/* expect+1: passing 'long' */
+	/* expect+1: ... passing 'long' ... */
 	print_type(3l);
+}
 void
 suffix_ul(void)
+{
-	/* expect+1: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(3UL);
-	/* expect+1: passing 'unsigned long' */
+	/* expect+1: ... passing 'unsigned long' ... */
 	print_type(3LU);
+}
 void
 suffix_ll(void)
+{
-	/* expect+1: passing 'long long' */
+	/* expect+1: ... passing 'long long' ... */
 	print_type(3LL);
 	/* The 'Ll' must not use mixed case. Checked by the compiler. */
-	/* expect+1: passing 'long long' */
+	/* expect+1: ... passing 'long long' ... */
 	print_type(3Ll);
-	/* expect+1: passing 'long long' */
+	/* expect+1: ... passing 'long long' ... */
 	print_type(3ll);
+}
 void
 suffix_ull(void)
+{
-	/* expect+1: passing 'unsigned long long' */
+	/* expect+1: ... passing 'unsigned long long' ... */
 	print_type(3llu);
-	/* expect+1: passing 'unsigned long long' */
+	/* expect+1: ... passing 'unsigned long long' ... */
 	print_type(3Ull);
 	/* The 'LL' must not be split. Checked by the compiler. */
-	/* expect+1: passing 'unsigned long long' */
+	/* expect+1: ... passing 'unsigned long long' ... */
 	print_type(3lul);
 	/* The 'Ll' must not use mixed case. Checked by the compiler. */
-	/* expect+1: passing 'unsigned long long' */
+	/* expect+1: ... passing 'unsigned long long' ... */
 	print_type(3ULl);
+}
 void
 suffix_too_many(void)
+{
 	/* expect+2: warning: malformed integer constant [251] */
-	/* expect+1: passing 'long long' */
+	/* expect+1: ... passing 'long long' ... */
 	print_type(3LLL);
 	/* expect+2: warning: malformed integer constant [251] */
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(3uu);
+}
 /* https://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html */
 void
 binary_literal(void)
+{
 	/* This is a GCC extension, but lint doesn't know that. */
-	/* expect+1: passing 'int' */
+	/* expect+1: ... passing 'int' ... */
 	print_type(0b1111000001011010);
-	/* expect+1: passing 'unsigned int' */
+	/* expect+1: ... passing 'unsigned int' ... */
 	print_type(0b11110000111100001111000011110000);
+}

--- src/tests/usr.bin/xlint/lint1/msg_031.c 2022/06/15 20:18:31	1.7
+++ src/tests/usr.bin/xlint/lint1/msg_031.c 2022/06/17 18:54:53	1.8

 @@ -1,21 +1,21 @@
-/*	$NetBSD: msg_031.c,v 1.7 2022/06/15 20:18:31 rillig Exp $	*/
+/*	$NetBSD: msg_031.c,v 1.8 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_031.c"
 // Test for message: '%s' has incomplete type '%s' [31]
 struct complete {
 	int dummy;
 };
 /* expect+1: warning: struct 'incomplete' never defined [233] */
 struct incomplete;
 struct complete complete_var;
-/* expect+1: 'incomplete_var' has incomplete type 'incomplete struct incomplete' */
+/* expect+1: error: 'incomplete_var' has incomplete type 'incomplete struct incomplete' [31] */
 struct incomplete incomplete_var;
-/* expect+1: '<unnamed>' has incomplete type 'incomplete struct incomplete' [31] */
+/* expect+1: error: '<unnamed>' has incomplete type 'incomplete struct incomplete' [31] */
 void function(struct incomplete);

--- src/tests/usr.bin/xlint/lint1/msg_259_ilp32.c 2022/04/16 18:41:21	1.7
+++ src/tests/usr.bin/xlint/lint1/msg_259_ilp32.c 2022/06/17 18:54:53	1.8

 @@ -1,37 +1,37 @@
-/*	$NetBSD: msg_259_ilp32.c,v 1.7 2022/04/16 18:41:21 rillig Exp $	*/
+/*	$NetBSD: msg_259_ilp32.c,v 1.8 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_259_ilp32.c"
 /* Test for message: argument #%d is converted from '%s' to '%s' due to prototype [259] */
 /*
  * See also msg_259, which contains more examples for this warning.
+ *
  * See also msg_297, but that requires the flags -a -p -P, which are not
  * enabled in the default NetBSD build.
  */
 /* lint1-only-if: ilp32 */
 /* lint1-flags: -h -w */
 void plain_char(char);
 void signed_int(int);
 void signed_long(long);
 void
 example(char c, int i, long l)
+{
 	plain_char(c);
 	signed_int(c);
-	/* expect+1: from 'char' to 'long' due to prototype [259] */
+	/* expect+1: ... from 'char' to 'long' due to prototype [259] */
 	signed_long(c);
 	plain_char(i);
 	signed_int(i);
-	/* expect+1: from 'int' to 'long' due to prototype [259] */
+	/* expect+1: ... from 'int' to 'long' due to prototype [259] */
 	signed_long(i);
 	plain_char(l);
-	/* expect+1: from 'long' to 'int' due to prototype [259] */
+	/* expect+1: ... from 'long' to 'int' due to prototype [259] */
 	signed_int(l);
 	signed_long(l);
+}

--- src/tests/usr.bin/xlint/lint1/msg_193.c 2022/06/16 16:58:36	1.18
+++ src/tests/usr.bin/xlint/lint1/msg_193.c 2022/06/17 18:54:53	1.19

	@@ -1,14 +1,14 @@		@@ -1,14 +1,14 @@
1	/* $NetBSD: msg_193.c,v 1.18 2022/06/16 16:58:36 rillig Exp $ */	1	/* $NetBSD: msg_193.c,v 1.19 2022/06/17 18:54:53 rillig Exp $ */
2	# 3 "msg_193.c"	2	# 3 "msg_193.c"
3		3
4	// Test for message: statement not reached [193]	4	// Test for message: statement not reached [193]
5		5
6	/*	6	/*
7	* Test the reachability of statements in a function.	7	* Test the reachability of statements in a function.
8	*	8	*
9	* if	9	* if
10	* if-else	10	* if-else
11	* if-else-if-else	11	* if-else-if-else
12	* for	12	* for
13	* while	13	* while
14	* do-while	14	* do-while
	@@ -42,512 +42,512 @@ test_compound_statement(void)		@@ -42,512 +42,512 @@ test_compound_statement(void)
42	reachable();	42	reachable();
43	reachable();	43	reachable();
44	}	44	}
45	reachable();	45	reachable();
46	}	46	}
47		47
48	void	48	void
49	test_if_statement(void)	49	test_if_statement(void)
50	{	50	{
51	if (1)	51	if (1)
52	reachable();	52	reachable();
53	reachable();	53	reachable();
54	if (0)	54	if (0)
55	unreachable(); /* expect+0: 193 */	55	unreachable(); /* expect+0: ... [193] */
56	reachable();	56	reachable();
57	}	57	}
58		58
59	void	59	void
60	test_if_compound_statement(void)	60	test_if_compound_statement(void)
61	{	61	{
62	if (1) {	62	if (1) {
63	reachable();	63	reachable();
64	}	64	}
65	if (1) {	65	if (1) {
66	{	66	{
67	{	67	{
68	reachable();	68	reachable();
69	}	69	}
70	}	70	}
71	}	71	}
72		72
73	if (0) {	73	if (0) {
74	unreachable(); /* expect+0: 193 */	74	unreachable(); /* expect+0: ... [193] */
75	}	75	}
76	if (0) {	76	if (0) {
77	{	77	{
78	{	78	{
79	unreachable(); /* expect+0: 193 */	79	unreachable(); /* expect+0: ... [193] */
80	}	80	}
81	}	81	}
82	}	82	}
83	}	83	}
84		84
85	void	85	void
86	test_if_without_else(void)	86	test_if_without_else(void)
87	{	87	{
88	if (1)	88	if (1)
89	reachable();	89	reachable();
90	reachable();	90	reachable();
91		91
92	if (0)	92	if (0)
93	unreachable(); /* expect+0: 193 */	93	unreachable(); /* expect+0: ... [193] */
94	reachable();	94	reachable();
95	}	95	}
96		96
97	void	97	void
98	test_if_with_else(void)	98	test_if_with_else(void)
99	{	99	{
100	if (1)	100	if (1)
101	reachable();	101	reachable();
102	else	102	else
103	unreachable(); /* expect+0: 193 */	103	unreachable(); /* expect+0: ... [193] */
104	reachable();	104	reachable();
105		105
106	if (0)	106	if (0)
107	unreachable(); /* expect+0: 193 */	107	unreachable(); /* expect+0: ... [193] */
108	else	108	else
109	reachable();	109	reachable();
110	reachable();	110	reachable();
111	}	111	}
112		112
113	void	113	void
114	test_if_else_if_else(void)	114	test_if_else_if_else(void)
115	{	115	{
116	if (1)	116	if (1)
117	reachable();	117	reachable();
118	else if (1) /* expect+0: 193 */	118	else if (1) /* expect+0: ... [193] */
119	unreachable();	119	unreachable();
120	else	120	else
121	unreachable(); /* expect+0: 193 */	121	unreachable(); /* expect+0: ... [193] */
122		122
123	if (0)	123	if (0)
124	unreachable(); /* expect+0: 193 */	124	unreachable(); /* expect+0: ... [193] */
125	else if (1)	125	else if (1)
126	reachable();	126	reachable();
127	else	127	else
128	unreachable(); /* expect+0: 193 */	128	unreachable(); /* expect+0: ... [193] */
129		129
130	if (0)	130	if (0)
131	unreachable(); /* expect+0: 193 */	131	unreachable(); /* expect+0: ... [193] */
132	else if (0)	132	else if (0)
133	unreachable(); /* expect+0: 193 */	133	unreachable(); /* expect+0: ... [193] */
134	else	134	else
135	reachable();	135	reachable();
136	}	136	}
137		137
138	void	138	void
139	test_if_return(void)	139	test_if_return(void)
140	{	140	{
141	if (1)	141	if (1)
142	return;	142	return;
143	unreachable(); /* expect+0: 193 */	143	unreachable(); /* expect+0: ... [193] */
144	}	144	}
145		145
146	void	146	void
147	test_if_else_return(void)	147	test_if_else_return(void)
148	{	148	{
149	if (1)	149	if (1)
150	reachable();	150	reachable();
151	else	151	else
152	return; /* expect+0: 193 */	152	return; /* expect+0: ... [193] */
153	reachable();	153	reachable();
154	}	154	}
155		155
156	void	156	void
157	test_for_forever(void)	157	test_for_forever(void)
158	{	158	{
159	for (;;)	159	for (;;)
160	reachable();	160	reachable();
161	unreachable(); /* expect+0: 193 */	161	unreachable(); /* expect+0: ... [193] */
162	}	162	}
163		163
164	void	164	void
165	test_for_true(void)	165	test_for_true(void)
166	{	166	{
167	for (; 1;)	167	for (; 1;)
168	reachable();	168	reachable();
169	unreachable(); /* expect+0: 193 */	169	unreachable(); /* expect+0: ... [193] */
170	}	170	}
171		171
172	void	172	void
173	test_for_false(void)	173	test_for_false(void)
174	{	174	{
175	for (; 0;)	175	for (; 0;)
176	unreachable(); /* expect+0: 193 */	176	unreachable(); /* expect+0: ... [193] */
177	reachable();	177	reachable();
178	}	178	}
179		179
180	void	180	void
181	test_for_break(void)	181	test_for_break(void)
182	{	182	{
183	for (;;) {	183	for (;;) {
184	reachable();	184	reachable();
185	break;	185	break;
186	unreachable(); /* expect+0: 193 */	186	unreachable(); /* expect+0: ... [193] */
187	}	187	}
188	reachable();	188	reachable();
189	}	189	}
190		190
191	void	191	void
192	test_for_if_break(void)	192	test_for_if_break(void)
193	{	193	{
194	for (;;) {	194	for (;;) {
195	reachable();	195	reachable();
196	if (0) {	196	if (0) {
197	unreachable(); /* expect+0: 193 */	197	unreachable(); /* expect+0: ... [193] */
198	break;	198	break;
199	unreachable(); /* expect+0: 193 */	199	unreachable(); /* expect+0: ... [193] */
200	}	200	}
201	if (1) {	201	if (1) {
202	reachable();	202	reachable();
203	break;	203	break;
204	unreachable(); /* expect+0: 193 */	204	unreachable(); /* expect+0: ... [193] */
205	}	205	}
206	unreachable(); /* expect+0: 193 */	206	unreachable(); /* expect+0: ... [193] */
207	}	207	}
208	reachable();	208	reachable();
209	}	209	}
210		210
211	void	211	void
212	test_for_continue(void)	212	test_for_continue(void)
213	{	213	{
214	for (;;) {	214	for (;;) {
215	reachable();	215	reachable();
216	continue;	216	continue;
217	unreachable(); /* expect+0: 193 */	217	unreachable(); /* expect+0: ... [193] */
218	}	218	}
219	unreachable(); /* expect+0: 193 */	219	unreachable(); /* expect+0: ... [193] */
220	}	220	}
221		221
222	void	222	void
223	test_for_if_continue(void)	223	test_for_if_continue(void)
224	{	224	{
225	for (;;) {	225	for (;;) {
226	reachable();	226	reachable();
227	if (0) {	227	if (0) {
228	unreachable(); /* expect+0: 193 */	228	unreachable(); /* expect+0: ... [193] */
229	continue;	229	continue;
230	unreachable(); /* expect+0: 193 */	230	unreachable(); /* expect+0: ... [193] */
231	}	231	}
232	if (1) {	232	if (1) {
233	reachable();	233	reachable();
234	continue;	234	continue;
235	unreachable(); /* expect+0: 193 */	235	unreachable(); /* expect+0: ... [193] */
236	}	236	}
237	unreachable(); /* expect+0: 193 */	237	unreachable(); /* expect+0: ... [193] */
238	}	238	}
239	unreachable(); /* expect+0: 193 */	239	unreachable(); /* expect+0: ... [193] */
240	}	240	}
241		241
242	void	242	void
243	test_for_return(void)	243	test_for_return(void)
244	{	244	{
245	for (;;) {	245	for (;;) {
246	reachable();	246	reachable();
247	return;	247	return;
248	unreachable(); /* expect+0: 193 */	248	unreachable(); /* expect+0: ... [193] */
249	}	249	}
250	unreachable(); /* expect+0: 193 */	250	unreachable(); /* expect+0: ... [193] */
251	}	251	}
252		252
253	void	253	void
254	test_for_if_return(void)	254	test_for_if_return(void)
255	{	255	{
256	for (;;) {	256	for (;;) {
257	reachable();	257	reachable();
258	if (0) {	258	if (0) {
259	unreachable(); /* expect+0: 193 */	259	unreachable(); /* expect+0: ... [193] */
260	return;	260	return;
261	unreachable(); /* expect+0: 193 */	261	unreachable(); /* expect+0: ... [193] */
262	}	262	}
263	if (1) {	263	if (1) {
264	reachable();	264	reachable();
265	return;	265	return;
266	unreachable(); /* expect+0: 193 */	266	unreachable(); /* expect+0: ... [193] */
267	}	267	}
268	unreachable(); /* expect+0: 193 */	268	unreachable(); /* expect+0: ... [193] */
269	}	269	}
270	unreachable(); /* expect+0: 193 */	270	unreachable(); /* expect+0: ... [193] */
271	}	271	}
272		272
273	void	273	void
274	test_while_true(void)	274	test_while_true(void)
275	{	275	{
276	while (1)	276	while (1)
277	reachable();	277	reachable();
278	unreachable(); /* expect+0: 193 */	278	unreachable(); /* expect+0: ... [193] */
279	}	279	}
280		280
281	void	281	void
282	test_while_false(void)	282	test_while_false(void)
283	{	283	{
284	while (0)	284	while (0)
285	unreachable(); /* expect+0: 193 */	285	unreachable(); /* expect+0: ... [193] */
286	reachable();	286	reachable();
287	}	287	}
288		288
289	void	289	void
290	test_while_break(void)	290	test_while_break(void)
291	{	291	{
292	while (1) {	292	while (1) {
293	reachable();	293	reachable();
294	break;	294	break;
295	unreachable(); /* expect+0: 193 */	295	unreachable(); /* expect+0: ... [193] */
296	}	296	}
297	reachable();	297	reachable();
298	}	298	}
299		299
300	void	300	void
301	test_while_if_break(void)	301	test_while_if_break(void)
302	{	302	{
303	while (1) {	303	while (1) {
304	reachable();	304	reachable();
305	if (0) {	305	if (0) {
306	unreachable(); /* expect+0: 193 */	306	unreachable(); /* expect+0: ... [193] */
307	break;	307	break;
308	unreachable(); /* expect+0: 193 */	308	unreachable(); /* expect+0: ... [193] */
309	}	309	}
310	if (1) {	310	if (1) {
311	reachable();	311	reachable();
312	break;	312	break;
313	unreachable(); /* expect+0: 193 */	313	unreachable(); /* expect+0: ... [193] */
314	}	314	}
315	unreachable(); /* expect+0: 193 */	315	unreachable(); /* expect+0: ... [193] */
316	}	316	}
317	reachable();	317	reachable();
318	}	318	}
319		319
320	void	320	void
321	test_while_continue(void)	321	test_while_continue(void)
322	{	322	{
323	while (1) {	323	while (1) {
324	reachable();	324	reachable();
325	continue;	325	continue;
326	unreachable(); /* expect+0: 193 */	326	unreachable(); /* expect+0: ... [193] */
327	}	327	}
328	unreachable(); /* expect+0: 193 */	328	unreachable(); /* expect+0: ... [193] */
329	}	329	}
330		330
331	void	331	void
332	test_while_if_continue(void)	332	test_while_if_continue(void)
333	{	333	{
334	while (1) {	334	while (1) {
335	reachable();	335	reachable();
336	if (0) {	336	if (0) {
337	unreachable(); /* expect+0: 193 */	337	unreachable(); /* expect+0: ... [193] */
338	continue;	338	continue;
339	unreachable(); /* expect+0: 193 */	339	unreachable(); /* expect+0: ... [193] */
340	}	340	}
341	if (1) {	341	if (1) {
342	reachable();	342	reachable();
343	continue;	343	continue;
344	unreachable(); /* expect+0: 193 */	344	unreachable(); /* expect+0: ... [193] */
345	}	345	}
346	unreachable(); /* expect+0: 193 */	346	unreachable(); /* expect+0: ... [193] */
347	}	347	}
348	unreachable(); /* expect+0: 193 */	348	unreachable(); /* expect+0: ... [193] */
349	}	349	}
350		350
351	void	351	void
352	test_while_return(void)	352	test_while_return(void)
353	{	353	{
354	while (1) {	354	while (1) {
355	reachable();	355	reachable();
356	return;	356	return;
357	unreachable(); /* expect+0: 193 */	357	unreachable(); /* expect+0: ... [193] */
358	}	358	}
359	unreachable(); /* expect+0: 193 */	359	unreachable(); /* expect+0: ... [193] */
360	}	360	}
361		361
362	void	362	void
363	test_while_if_return(void)	363	test_while_if_return(void)
364	{	364	{
365	while (1) {	365	while (1) {
366	reachable();	366	reachable();
367	if (0) {	367	if (0) {
368	unreachable(); /* expect+0: 193 */	368	unreachable(); /* expect+0: ... [193] */
369	return;	369	return;
370	unreachable(); /* expect+0: 193 */	370	unreachable(); /* expect+0: ... [193] */
371	}	371	}
372	if (1) {	372	if (1) {
373	reachable();	373	reachable();
374	return;	374	return;
375	unreachable(); /* expect+0: 193 */	375	unreachable(); /* expect+0: ... [193] */
376	}	376	}
377	unreachable(); /* expect+0: 193 */	377	unreachable(); /* expect+0: ... [193] */
378	}	378	}
379	unreachable(); /* expect+0: 193 */	379	unreachable(); /* expect+0: ... [193] */
380	}	380	}
381		381
382	void	382	void
383	test_do_while_true(void)	383	test_do_while_true(void)
384	{	384	{
385	do {	385	do {
386	reachable();	386	reachable();
387	} while (1);	387	} while (1);
388	unreachable(); /* expect+0: 193 */	388	unreachable(); /* expect+0: ... [193] */
389	}	389	}
390		390
391	void	391	void
392	test_do_while_false(void)	392	test_do_while_false(void)
393	{	393	{
394	do {	394	do {
395	reachable();	395	reachable();
396	} while (0);	396	} while (0);
397	reachable();	397	reachable();
398	}	398	}
399		399
400	void	400	void
401	test_do_while_break(void)	401	test_do_while_break(void)
402	{	402	{
403	do {	403	do {
404	reachable();	404	reachable();
405	break;	405	break;
406	unreachable(); /* expect+0: 193 */	406	unreachable(); /* expect+0: ... [193] */
407	} while (1);	407	} while (1);
408	reachable();	408	reachable();
409	}	409	}
410		410
411	void	411	void
412	test_do_while_if_break(void)	412	test_do_while_if_break(void)
413	{	413	{
414	do {	414	do {
415	reachable();	415	reachable();
416	if (0) {	416	if (0) {
417	unreachable(); /* expect+0: 193 */	417	unreachable(); /* expect+0: ... [193] */
418	break;	418	break;
419	unreachable(); /* expect+0: 193 */	419	unreachable(); /* expect+0: ... [193] */
420	}	420	}
421	if (1) {	421	if (1) {
422	reachable();	422	reachable();
423	break;	423	break;
424	unreachable(); /* expect+0: 193 */	424	unreachable(); /* expect+0: ... [193] */
425	}	425	}
426	unreachable(); /* expect+0: 193 */	426	unreachable(); /* expect+0: ... [193] */
427	} while (1);	427	} while (1);
428	reachable();	428	reachable();
429	}	429	}
430		430
431	void	431	void
432	test_do_while_continue(void)	432	test_do_while_continue(void)
433	{	433	{
434	do {	434	do {
435	reachable();	435	reachable();
436	continue;	436	continue;
437	unreachable(); /* expect+0: 193 */	437	unreachable(); /* expect+0: ... [193] */
438	} while (1);	438	} while (1);
439	unreachable(); /* expect+0: 193 */	439	unreachable(); /* expect+0: ... [193] */
440	}	440	}
441		441
442	void	442	void
443	test_do_while_if_continue(void)	443	test_do_while_if_continue(void)
444	{	444	{
445	do {	445	do {
446	reachable();	446	reachable();
447	if (0) {	447	if (0) {
448	unreachable(); /* expect+0: 193 */	448	unreachable(); /* expect+0: ... [193] */
449	continue;	449	continue;
450	unreachable(); /* expect+0: 193 */	450	unreachable(); /* expect+0: ... [193] */
451	}	451	}
452	if (1) {	452	if (1) {
453	reachable();	453	reachable();
454	continue;	454	continue;
455	unreachable(); /* expect+0: 193 */	455	unreachable(); /* expect+0: ... [193] */
456	}	456	}
457	unreachable(); /* expect+0: 193 */	457	unreachable(); /* expect+0: ... [193] */
458	} while (1);	458	} while (1);
459	unreachable(); /* expect+0: 193 */	459	unreachable(); /* expect+0: ... [193] */
460	}	460	}
461		461
462	void	462	void
463	test_do_while_return(void)	463	test_do_while_return(void)
464	{	464	{
465	do {	465	do {
466	reachable();	466	reachable();
467	return;	467	return;
468	unreachable(); /* expect+0: 193 */	468	unreachable(); /* expect+0: ... [193] */
469	} while (1);	469	} while (1);
470	unreachable(); /* expect+0: 193 */	470	unreachable(); /* expect+0: ... [193] */
471	}	471	}
472		472
473	void	473	void
474	test_do_while_if_return(void)	474	test_do_while_if_return(void)
475	{	475	{
476	do {	476	do {
477	reachable();	477	reachable();
478	if (0) {	478	if (0) {
479	unreachable(); /* expect+0: 193 */	479	unreachable(); /* expect+0: ... [193] */
480	return;	480	return;
481	unreachable(); /* expect+0: 193 */	481	unreachable(); /* expect+0: ... [193] */
482	}	482	}
483	if (1) {	483	if (1) {
484	reachable();	484	reachable();
485	return;	485	return;
486	unreachable(); /* expect+0: 193 */	486	unreachable(); /* expect+0: ... [193] */
487	}	487	}
488	unreachable(); /* expect+0: 193 */	488	unreachable(); /* expect+0: ... [193] */
489	} while (1);	489	} while (1);
490	unreachable(); /* expect+0: 193 */	490	unreachable(); /* expect+0: ... [193] */
491	}	491	}
492		492
493	void	493	void
494	test_if_nested(void)	494	test_if_nested(void)
495	{	495	{
496	if (0) {	496	if (0) {
497	if (1) /* expect+0: 193 */	497	if (1) /* expect+0: ... [193] */
498	unreachable();	498	unreachable();
499	else	499	else
500	unreachable(); /* expect+0: 193 // XXX: redundant */	500	unreachable(); /* expect+0: ... [193] // XXX: redundant */
501		501
502	if (0)	502	if (0)
503	unreachable(); /* expect+0: 193 // XXX: redundant */	503	unreachable(); /* expect+0: ... [193] // XXX: redundant */
504	else	504	else
505	unreachable();	505	unreachable();
506		506
507	unreachable();	507	unreachable();
508	}	508	}
509	reachable();	509	reachable();
510		510
511	if (1) {	511	if (1) {
512	if (1)	512	if (1)
513	reachable();	513	reachable();
514	else	514	else
515	unreachable(); /* expect+0: 193 */	515	unreachable(); /* expect+0: ... [193] */
516		516
517	if (0)	517	if (0)
518	unreachable(); /* expect+0: 193 */	518	unreachable(); /* expect+0: ... [193] */
519	else	519	else
520	reachable();	520	reachable();
521		521
522	reachable();	522	reachable();
523	}	523	}
524	reachable();	524	reachable();
525	}	525	}
526		526
527	void	527	void
528	test_if_maybe(void)	528	test_if_maybe(void)
529	{	529	{
530	if (maybe()) {	530	if (maybe()) {
531	if (0)	531	if (0)
532	unreachable(); /* expect+0: 193 */	532	unreachable(); /* expect+0: ... [193] */
533	else	533	else
534	reachable();	534	reachable();
535	reachable();	535	reachable();
536	}	536	}
537	reachable();	537	reachable();
538		538
539	if (0) {	539	if (0) {
540	if (maybe()) /* expect+0: 193 */	540	if (maybe()) /* expect+0: ... [193] */
541	unreachable();	541	unreachable();
542	else	542	else
543	unreachable();	543	unreachable();
544	unreachable();	544	unreachable();
545	}	545	}
546	reachable();	546	reachable();
547		547
548	if (1) {	548	if (1) {
549	if (maybe())	549	if (maybe())
550	reachable();	550	reachable();
551	else	551	else
552	reachable();	552	reachable();
553	reachable();	553	reachable();
	@@ -585,36 +585,36 @@ ten:		@@ -585,36 +585,36 @@ ten:
585	three:	585	three:
586	goto four;	586	goto four;
587	two:	587	two:
588	goto three;	588	goto three;
589	}	589	}
590		590
591	void	591	void
592	test_while_goto(void)	592	test_while_goto(void)
593	{	593	{
594	while (1) {	594	while (1) {
595	goto out;	595	goto out;
596	break; /* lint only warns with the -b option */	596	break; /* lint only warns with the -b option */
597	}	597	}
598	unreachable(); /* expect+0: 193 */	598	unreachable(); /* expect+0: ... [193] */
599	out:	599	out:
600	reachable();	600	reachable();
601	}	601	}
602		602
603	void	603	void
604	test_unreachable_label(void)	604	test_unreachable_label(void)
605	{	605	{
606	if (0)	606	if (0)
607	goto unreachable; /* expect+0: 193 */	607	goto unreachable; /* expect+0: ... [193] */
608	goto reachable;	608	goto reachable;
609		609
610	/* named_label assumes that any label is reachable. */	610	/* named_label assumes that any label is reachable. */
611	unreachable:	611	unreachable:
612	unreachable();	612	unreachable();
613	reachable:	613	reachable:
614	reachable();	614	reachable();
615	}	615	}
616		616
617	/* TODO: switch */	617	/* TODO: switch */
618		618
619	/* TODO: system-dependent constant expression (see tn_system_dependent) */	619	/* TODO: system-dependent constant expression (see tn_system_dependent) */
620		620

--- src/tests/usr.bin/xlint/lint1/msg_259.c 2022/04/15 21:50:07	1.20
+++ src/tests/usr.bin/xlint/lint1/msg_259.c 2022/06/17 18:54:53	1.21

 @@ -1,14 +1,14 @@
-/*	$NetBSD: msg_259.c,v 1.20 2022/04/15 21:50:07 rillig Exp $	*/
+/*	$NetBSD: msg_259.c,v 1.21 2022/06/17 18:54:53 rillig Exp $	*/
 # 3 "msg_259.c"
 // Test for message: argument #%d is converted from '%s' to '%s' due to prototype [259]
 /*
  * This warning detects function calls that are translated in very different
  * translation environments, one where prototypes are omitted, and one where
  * prototypes are active.  It is possible to make such code interoperable,
  * but that requires that each argument is converted to its proper type by
  * the caller of the function.
+ *
  * When lint is run with the '-s' flag, it no longer warns about code with
  * incompatibilities between traditional C and C90, therefore this test omits
 @@ -38,27 +38,27 @@ void
 change_in_type_width(char c, int i, long l)
+{
 	plain_char(c);
 	signed_int(c);
 	/* No warning 259 on LP64, only on ILP32 */
 	signed_long(c);
 	plain_char(i);		/* XXX: why no warning? */
 	signed_int(i);
 	/* No warning 259 on LP64, only on ILP32 */
 	signed_long(i);
 	plain_char(l);		/* XXX: why no warning? */
-	/* expect+1: from 'long' to 'int' due to prototype [259] */
+	/* expect+1: ... from 'long' to 'int' due to prototype [259] */
 	signed_int(l);
 	signed_long(l);
+}
 /*
  * Converting a signed integer type to its corresponding unsigned integer
  * type (C99 6.2.5p6) is usually not a problem since the actual values of the
  * expressions are usually not anywhere near the maximum signed value.  From
  * a technical standpoint, it is correct to warn here since even small
  * negative numbers may result in very large positive numbers.
+ *
  * A common case where it occurs is when the difference of two pointers is
  * converted to size_t.  The type ptrdiff_t is defined to be signed, but in

--- src/usr.bin/xlint/lint1/README.md 2022/06/15 18:11:02	1.5
+++ src/usr.bin/xlint/lint1/README.md 2022/06/17 18:54:53	1.6

 @@ -1,14 +1,14 @@
-[//]: # ($NetBSD: README.md,v 1.5 2022/06/15 18:11:02 rillig Exp $)
+[//]: # ($NetBSD: README.md,v 1.6 2022/06/17 18:54:53 rillig Exp $)
 # Introduction
 Lint1 analyzes a single translation unit of C code.
 * It reads the output of the C preprocessor, comments are retained.
 * The lexer in `scan.l` and `lex.c` splits the input into tokens.
 * The parser in `cgram.y` creates types and expressions from the tokens.
 * It checks declarations in `decl.c`.
 * It checks initializations in `init.c`.
 * It checks types and expressions in `tree.c`.
 To see how a specific lint message is triggered, read the corresponding unit
 @@ -150,26 +150,28 @@ By default, each test is run with the li
 `-S` for C99 mode and `-w` to report warnings as errors.
 Each test can override the lint flags using comments of the following forms:
 * `/* lint1-flags: -tw */` replaces the default flags.
 * `/* lint1-extra-flags: -p */` adds to the default flags.
 Most tests check the diagnostics that lint generates.
 They do this by placing `expect` comments near the location of the diagnostic.
 The comment `/* expect+1: ... */` expects a diagnostic to be generated for the
 code 1 line below, `/* expect-5: ... */` expects a diagnostic to be generated
 for the code 5 lines above.
 Each `expect` comment must be in a single line.
-There may be other code or comments in the same line.
+At the start and the end of the comment, the placeholder `...` stands for an
 arbitrary sequence of characters.
 There may be other code or comments in the same line of the `.c` file.
 Each diagnostic has its own test `msg_???.c` that triggers the corresponding
 diagnostic.
 Most other tests focus on a single feature.
 ## Adding a new test
 . Run `make add-test NAME=test_name`.
 . Sort the `FILES` lines in `../../tests/usr.bin/xlint/lint1/Makefile`.
 . Make the test generate the desired diagnostics.
 . Run `cd ../../tests/usr.bin/xlint/lint1 && sh ./accept.sh test_name`.
 . Run `cd ../.. && cvs commit distrib/sets/lists/tests/mi tests/usr.bin/xlint`.