Render diagnostics through the terminal library (#7683)

Diagnostic rendering was part of the data model: `Loc::FormatLocation`
and
`Loc::FormatSnippet` wrote plain text to a stream, so no capability,
color, or
terminal width could reach them.

A diagnostic is now one message with labels, contexts, and location
information
attached, and `Diagnostics::Renderer` draws it into a
`Terminal::Buffer`. The
design is in `toolchain/docs/diagnostics_rendering.md` (#7668),
authoring in
`toolchain/docs/diagnostics.md`.

Before:

```
example.carbon:6:3: error: 1 argument passed to function expecting 0 arguments
  Run0(1);
  ^~~~~~~
example.carbon:3:1: note: calling function declared here
fn Run0() {}
^~~~~~~~~~~
```

After:

```
error: 1 argument passed to function expecting 0 arguments
       ╭─┤ example.carbon:6:3
       ┆
     3 │ fn Run0() {}
       · ─────┬─────
       ·      ╰──┤ calling function declared here
       ┆
->   6 │   Run0(1);
       ·   ───────
       ╰────────────
```

`--no-diagnostic-snippets` gives a compact form, `example.carbon:6:3-9`.
File
tests use it; the rendering tests under `toolchain/diagnostics/testdata`
ask for
snippets.

C++ interop diagnostics are data now rather than text Clang drew:
`SemIR::ClangSourceLocId` names a `clang::SourceRange`, and a Clang
location is
marked as the point it names.

`StreamConsumer` moves to a `:renderer` target that `:emitter` does not
depend
on, keeping `common/terminal` out of `consumer.h`. Capabilities come
from the
file behind the error stream, so tests get plain ASCII.

`renderer_fuzzer` draws diagnostics built from fuzzer bytes with every
capability combination, since a shape the renderer doesn't expect must
never be
why the compiler dies while reporting a problem.

TODOs mark the follow-ups: line weights and crossing lines, wrapping
that keeps
a quoted type whole, and ordering diagnostics that share a byte offset.

Also: `IncorrectExtension`'s hint moves into its message, since its note
had no
location of its own, and `strip_noise` in `check_diagnostics.py` blanks
multi-line `#define`s instead of deleting them.

Assisted-by: Claude Code

toolchain/check/cpp/location.cpp

@@ -6,6 +6,7 @@
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/SourceManager.h"
+#include "toolchain/lex/tokenized_buffer.h"
 #include "toolchain/sem_ir/absolute_node_ref.h"
 #include "toolchain/sem_ir/ids.h"
 
@@ -68,8 +69,10 @@ auto GetCppLocation(Context& context, SemIR::LocId loc_id)
       SemIR::GetAbsoluteNodeRef(&context.sem_ir(), loc_id);
   const auto& final_node = absolute_node_refs.back();
   if (final_node.is_cpp()) {
-    return final_node.file()->clang_source_locs().Get(
-        final_node.clang_source_loc_id());
+    return final_node.file()
+        ->clang_source_locs()
+        .Get(final_node.clang_source_loc_id())
+        .getBegin();
   }
 
   if (!final_node.node_id().has_value()) {
@@ -88,11 +91,55 @@ auto GetCppLocation(Context& context, SemIR::LocId loc_id)
   return start_loc.getLocWithOffset(offset);
 }
 
-auto AddImportIRInst(SemIR::File& file, clang::SourceLocation clang_source_loc)
+auto GetCppRange(Context& context, SemIR::LocId loc_id)
+    -> clang::CharSourceRange {
+  if (!context.sem_ir().cpp_file()) {
+    return clang::CharSourceRange();
+  }
+
+  llvm::SmallVector<SemIR::AbsoluteNodeRef> absolute_node_refs =
+      SemIR::GetAbsoluteNodeRef(&context.sem_ir(), loc_id);
+  const auto& final_node = absolute_node_refs.back();
+  if (final_node.is_cpp()) {
+    auto loc = GetCppLocation(context, loc_id);
+    return clang::CharSourceRange::getTokenRange(loc, loc);
+  }
+  if (!final_node.node_id().has_value()) {
+    return clang::CharSourceRange();
+  }
+
+  auto [ir, start_loc] = GetFileInfo(context, final_node.check_ir_id());
+  const auto& tokens = ir->parse_tree().tokens();
+  auto token = ir->parse_tree().node_token(final_node.node_id());
+  // Only the file being checked has its subtrees available, since a `Context`
+  // holds the one `TreeAndSubtrees`.
+  Lex::InclusiveTokenRange token_range = {.begin = token, .end = token};
+  if (final_node.check_ir_id() == context.sem_ir().check_ir_id()) {
+    token_range = context.parse_tree_and_subtrees().GetSubtreeTokenRange(
+        final_node.node_id());
+  }
+  return clang::CharSourceRange::getCharRange(
+      start_loc.getLocWithOffset(tokens.GetByteOffset(token_range.begin)),
+      start_loc.getLocWithOffset(tokens.GetByteOffset(token_range.end) +
+                                 tokens.GetTokenText(token_range.end).size()));
+}
+
+auto AddImportIRInst(SemIR::File& file, clang::CharSourceRange clang_range)
     -> SemIR::ImportIRInstId {
+  // Stored as its two ends: every range reaching here is a character range, so
+  // `CharSourceRange`'s token-or-character bit would always say the same thing
+  // and cost a word to say it. Rebuilt as one where it is read.
+  CARBON_CHECK(!clang_range.isTokenRange(),
+               "A token range would lose which it was; widen it first.");
   SemIR::ClangSourceLocId clang_source_loc_id =
-      file.clang_source_locs().Add(clang_source_loc);
+      file.clang_source_locs().Add(clang_range.getAsRange());
   return file.import_ir_insts().Add(SemIR::ImportIRInst(clang_source_loc_id));
 }
 
+auto AddImportIRInst(SemIR::File& file, clang::SourceLocation clang_source_loc)
+    -> SemIR::ImportIRInstId {
+  return AddImportIRInst(file, clang::CharSourceRange::getCharRange(
+                                   clang_source_loc, clang_source_loc));
+}
+
 }  // namespace Carbon::Check