improve error message for unterminated string and character literals

lib/std/zig/Ast.zig

@@ -458,6 +458,16 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
             return stream.writeAll("for input is not captured");
         },
 
+        .unterminated_literal => {
+            return stream.print("unterminated '{s} literal'", .{
+                switch (tree.source[tree.tokens.items(.start)[parse_error.token]]) {
+                    '\'' => "character",
+                    '"' => "string",
+                    else => unreachable,
+                },
+            });
+        },
+
         .invalid_byte => {
             const tok_slice = tree.source[tree.tokens.items(.start)[parse_error.token]..];
             return stream.print("{s} contains invalid byte: '{'}'", .{
@@ -3003,6 +3013,7 @@ pub const Error = struct {
         var_const_decl,
         extra_for_capture,
         for_input_not_captured,
+        unterminated_literal,
 
         zig_style_container,
         previous_field,

lib/std/zig/AstGen.zig

@@ -14039,15 +14039,29 @@ fn lowerAstErrors(astgen: *AstGen) !void {
             }
             break :blk idx - tok_start;
         };
-
-        const err: Ast.Error = .{
-            .tag = Ast.Error.Tag.invalid_byte,
-            .token = tok,
-            .extra = .{ .offset = bad_off },
-        };
+        const err: Ast.Error =
+            if ((start_char == '\"' or start_char == '\'') and // If `tok` is a string or character literal and...
+            (tok_start + bad_off == tree.source.len or // it's directly followed by EOF, or...
+            tree.source[tok_start + bad_off] == '\n')) // it's terminated by a newline.
+            .{
+                .tag = Ast.Error.Tag.unterminated_literal,
+                .token = tok,
+            }
+        else
+            .{
+                .tag = Ast.Error.Tag.invalid_byte,
+                .token = tok,
+                .extra = .{ .offset = bad_off },
+            };
         msg.clearRetainingCapacity();
         try tree.renderError(err, msg.writer(gpa));
-        return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.items}, notes.items);
+        return try astgen.appendErrorTokNotesOff(
+            tok,
+            if (err.tag == .invalid_byte) bad_off else 0,
+            "{s}",
+            .{msg.items},
+            notes.items,
+        );
     }
 
     var cur_err = tree.errors[0];

test/cases/compile_errors/character_literal_with_newline.zig

@@ -0,0 +1,8 @@
+const foo = 'a
+';
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:13: error: unterminated 'character literal'

test/cases/compile_errors/normal_string_with_newline.zig

@@ -5,4 +5,4 @@ b";
 // backend=stage2
 // target=native
 //
-// :1:15: error: string literal contains invalid byte: '\n'
+// :1:13: error: unterminated 'string literal'

test/compile_errors.zig

@@ -237,6 +237,22 @@ pub fn addCases(ctx: *Cases, b: *std.Build) !void {
         });
     }
 
+    {
+        const case = ctx.obj("unterminated character literal eof", b.graph.host);
+
+        case.addError("const c = '", &[_][]const u8{
+            ":1:11: error: unterminated 'character literal'",
+        });
+    }
+
+    {
+        const case = ctx.obj("unterminated string literal eof", b.graph.host);
+
+        case.addError("const s = \"hello, ", &[_][]const u8{
+            ":1:11: error: unterminated 'string literal'",
+        });
+    }
+
     {
         const case = ctx.obj("invalid byte at start of token", b.graph.host);